Selective cache flushing in identity and access management systems

ABSTRACT

The present invention provides cache flushing of selected data while leaving remaining cached data intact. Data can be flushed from caches distributed across various components of a network-based computer system. These caches can contain various types of data. In one embodiment, the caches exist in an Access System and contain user identity profile information. In another embodiment, the caches exist in an Access Management System and contain authentication, authorization, or auditing rules. A system in accordance with the invention detects a change to data residing on a server and transmits a synchronization record to a component of the system. The synchronization record identifies the changed data. The system flushes the changed data identified by the synchronization record from caches of the component.

This application claims the benefit of U.S. Provisional Application No.60/216,955, Web Access Management, filed Jul. 10, 2000, incorporatedherein by reference.

CROSS-REFERENCE TO RELATED APPLICATIONS

This Application is related to the following Applications:

Access Tester, by Christine Wai Han Chan, Attorney Docket No.OBLX-01011US0, filed the same day as the present application;

Post Data Processing, by Knouse, et al., Attorney Docket No.OBLX-01013US0, filed the same day as the present application;

User Authentication, by Martherus, et al., Attorney Docket No.OBLX-01014US0, filed the same day as the present application;

Localized Access, by Ramamurthy, et al., Attorney Docket No.OBLX-01015US0, filed the same day as the present application;

Query String Processing, by Crosbie, et al., Attorney Docket No.OBLX-01016US0, filed the same day as the present application;

Logging Access System Events, by Joshi, et al., Attorney Docket No.OBLX-01017US0, filed the same day as the present application;

Providing Data To Applications from an Access System, by Joshi, et al.,Attorney Docket No. OBLX-01018US0, filed the same day as the presentapplication; and

Intrusion Threat Detection, by Jeffrey D. Hodges, Attorney Docket No.OBLX-01020US0, filed the same day as the present application.

Each of these related Applications are incorporated herein by reference.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention is directed to technology for synchronizing andflushing the contents of cache memories.

2. Description of the Related Art

The Internet has altered the economic landscape, and companies areexperiencing a fundamental shift in how they do business. Businessprocesses involve complex interactions between companies and theircustomers, suppliers, partners and employees. For example, businessesinteract constantly with their customers—often other businesses—toprovide information on product specification and availability.Businesses also interact with vendors and suppliers in placing ordersand obtaining payments. To meet new challenges and leverageopportunities, while reducing their overall cost-of-interactions, manyorganizations are migrating to network-based business processes andmodels. Among the most important of these is Internet-based E-business.

In addition to customer information, businesses must also make a widearray of information and services available to their employeepopulations, generating further interactions. This information caninclude both business-related and personal information. E-business isalso challenged with cohesively managing disparate end user,application, content, policy, and administrative information. For all ofthese types of computer network-based information, as well as others, itis desirable to minimize the time spent retrieving the information toensure data is available quickly and accurately.

As the volume of data accessible to users through computer networkscontinues to surge, so has the number of end users attempting to accessthis data. As a result, the burden on access systems has increasedsignificantly, which can cause degradations in system performance. Theseconcerns become particularly acute in the world of E-commerce.

Cache memories provide one way to minimize data retrieval time. Caches(hardware or software) act as buffers, storing data that is frequentlyand/or recently accessed by various components of a network-basedsystem. Once data is stored in a cache, various components of the systemcan quickly read information directly from the cache, rather than havingto retrieve the data from an original source using a longer process.Generally speaking, data retrieved from a cache will be available muchquicker than data retrieved from original sources.

However, when data is changed at an original source, previously cachedversions of the data become stale. The cached data must be flushed toprevent usage of the stale data by components of the system. Cacheflushing is particularly important in systems where users areauthenticated or authorized for resources. For example, if changes occurto user information or rules used to authenticate or authorize users,any previously cached versions of the changed data must be flushed toprevent future authentication or authorizations from being performedusing the stale data.

Furthermore, if many pieces of data are cached, flushing an entire cachecan inadvertently delete data that has not been changed. This deletionof otherwise valid data can increase access times, forcing thecomponents of the system to re-retrieve previously cached data fromoriginal sources. This can lead to slower performance and loss ofconfidence in the E-business system.

These problems become further complicated in Internet network-basedcomputer systems where caches containing many disparate types ofinformation may be found on multiple servers, Web Servers, and even WebServer plug-ins running on the Web Servers. Thus, there is a need for ameans to flush stale cached data without interfering with otherwisevalid cached data in network-based computer systems.

SUMMARY OF THE INVENTION

The present invention, roughly described, provides for a system capableof flushing selected data from caches while leaving remaining cacheddata intact. The present invention can flush data from cachesdistributed across various components of a network-based system. Thesecaches can contain various types of data. In one embodiment, the cachesexist in an Access System and contain user identity profile information.In another embodiment, the caches exist in an Access Management Systemand contain authentication, authorization, or auditing rules.

One embodiment of the present invention detects a change to dataresiding on a server and transmits a synchronization record to acomponent of the system. The synchronization record identifies thechanged data. The system flushes the changed data identified by thesynchronization record from caches of the component. In one embodiment,the flushed cashes reside in an Access Server. In another embodiment,the flushed cashes reside in a Web Server plug-in.

The present invention can be implemented using hardware, software, or acombination of both hardware and software. The software used for thepresent invention is stored on one or more processor readable storagedevices including hard disk drives, CD-ROMs, DVDs, optical disks, floppydisks, tape drives, RAM, ROM or other suitable storage devices. Inalternative embodiments, some or all of the software can be replaced bydedicated hardware including custom integrated circuits, gate arrays,FPGAs, PLDs, and special purpose computers. Hardware that can be usedfor the present invention includes computers, handheld devices,telephones (e.g. cellular, Internet enabled, etc.), etc. Some of thesedevices includes processors, memory, nonvolatile storage, input devicesand output devices.

These and other objects and advantages of the present invention willappear more clearly from the following description in which thepreferred embodiment of the invention has been set forth in conjunctionwith the drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram depicting the components of one embodiment ofthe present invention.

FIG. 2 is a block diagram depicting the components of the computingsystem that can be used with the present invention.

FIG. 3 is a block diagram depicting the components of a DirectoryServer.

FIG. 4 is an example of a directory tree structure.

FIG. 5 is a flow chart describing a process for setting up access rulesfor an Identity Management System.

FIG. 6 is a flow chart describing a process for editing an attributeaccess criteria.

FIG. 7 is a flow chart describing a process for configuring localizedaccess.

FIG. 8 is a flow chart describing a process for controlling access toattributes in the Identity Management System.

FIG. 9 is a flow chart describing a process for determining access toattributes of a target.

FIG. 10 is a flow chart describing a process for determining whetherthere is a localized access violation for a class.

FIG. 11 is a flow chart describing a process for determining whetherthere is localized access for an attribute.

FIG. 12 is a flow chart describing a process for modifying an attribute.

FIG. 13 is a flow chart describing the active automation process.

FIG. 14 is a block diagram depicting the components of a Web Gate.

FIG. 15 is a block diagram depicting the components of an Access Server.

FIG. 16 is a flow chart describing a process for creating a policydomain.

FIG. 17 is a flow chart describing a process for adding an authorizationrule.

FIG. 18 is a flow chart describing a process for adding header variablesto an HTTP request.

FIG. 19 is a flow chart describing a process for adding anauthentication rule.

FIG. 20 is a flow chart describing a process for configuring an auditrule.

FIG. 21 is a flow chart describing a process for creating a policy.

FIG. 22 is a flow chart describing an exemplar process performed by theAccess System of one embodiment of the present invention.

FIG. 23 is a flow chart describing a process for determining whether aparticular resource is protected.

FIG. 24 is a flow chart describing a process for mapping a resource witha policy domain.

FIG. 25 is a flow chart describing a process for retrieving first andsecond level authentication rules.

FIG. 26 is a flow chart describing a process for determining whether aresource URL matches a specific policy URL.

FIG. 26A is a flow chart describing a process for determining whether aresource matches a specific policy using POST data.

FIG. 27 provides a block diagram of a retainer data structure.

FIG. 28 is a flow chart describing authentication.

FIG. 29 is a block diagram depicting various components involved in theauthentication process.

FIG. 30 is a flow chart describing a process for authentication.

FIG. 31 is a flow chart describing a process for retrieving anauthentication challenge scheme from a Directory Server.

FIG. 32 is a flow chart describing a method for performing basicauthentication.

FIG. 33 is a flow chart describing the process performed by an AccessServer to authenticate using a user ID and password.

FIG. 34 is a flow chart describing form authentication.

FIG. 35 is a flow chart describing a process for client certificateauthentication.

FIG. 36 is a flow chart describing a process for authenticating a userusing certificates.

FIG. 37 is a block diagram depicting the components of one embodiment ofan encrypted cookie.

FIG. 38 is a flowchart describing a process for authorization.

FIG. 39 is a flow chart describing the steps performed when passingauthorization information using POST data.

FIG. 40 is a block diagram of an exemplar HTTP request.

FIG. 41 is a flow chart describing a process for obtaining first andsecond level authorization rules from a Directory Server.

FIG. 42 is a flow chart describing a process for evaluating anauthorization rule.

FIG. 43 is a flow chart describing a process for applying anauthorization rule to extracted POST data.

FIG. 44 is a flow chart describing a process for performingauthentication success actions.

FIG. 45 is a flow chart describing a process for performingauthentication and authorization failure actions.

FIG. 46 is a flow chart describing a process for performingauthorization success actions.

FIG. 47 is a flow chart describing a process for using header variables.

FIG. 48 is a flow chart describing the steps performed by the auditingmodule of one embodiment of the present invention.

FIG. 49 is a flow chart describing a method for retrieving first andsecond level audit rules.

FIG. 50 is a block diagram depicting one embodiment of components usedfor intrusion detection.

FIG. 51 is a flow chart describing a process for detecting intrusions.

FIG. 52 is a flow chart describing a process performed at a securityserver as part of a process for detecting intrusions.

FIG. 53 is a flow chart describing a process for flushing/synchronizingcaches performed by an Access Manager.

FIG. 54 is a block diagram depicting a synchronization record.

FIG. 55 is a flow chart describing a process for flushing/synchronizingcaches performed by an Access Server.

FIG. 56 is a flow chart describing a process for flushing/synchronizingcaches performed by a Web Gate.

FIG. 57 is a flow chart describing a process for testing accesscriteria.

DETAILED DESCRIPTION

FIG. 1 depicts an Access System which provides identity management andaccess management for a network. In general, an Access System managesaccess to resources available to a network. The identity managementportion of the Access System (hereinafter “the Identity ManagementSystem”) manages end user identity profiles, while the access managementportion of the Access System (hereinafter “the Access ManagementSystem”) provides security for resources across one or more web servers.Underlying these modules is active automation, a delegation and workflow technology. The active automation technology couples the Identityand Access Management Systems by facilitating delegation of roles andrights, plus providing workflow-enabled management of end user identityprofiles. A key feature of one embodiment of this system is thecentralization of the repositories for policies and user identityprofiles while decentralizing their administration. That is, oneembodiment of the system centralizes the policy and identityrepositories by building them on a directory service technology. Thesystem decentralizes their administration by hierarchly delegatedAdministrative roles. Although the Access System of FIG. 1 includes anIdentity Management System and an Access Management System, other AccessSystems may only include an Identity Management System or only includean Access Management System.

FIG. 1 is a block diagram depicting one embodiment for deploying anAccess System. FIG. 1 shows web browsers 12 and 14 accessing Web Server18 and/or Administration Server 20 via Internet 16. In one embodiment,web browsers 12 and 14 are standard web browsers known in the artrunning on any suitable type of computer. FIG. 1 depicts web browsers 12and 14 communicating with Web Server 24 and Administration Server 20using HTTP over the Internet; however, other protocols and networks canalso be used.

Web Server 18 is a standard Web Server known in the art and provides anend user with access to various resources via Internet 16. In oneembodiment, there is a first firewall (not shown) connected betweenInternet 16 and Web Server 18, a second firewall (not shown) connectedbetween Web Server 18 and Access Server 34.

FIG. 1 shows two types of resources: resource 22 and resource 24.Resource 22 is external to Web Server 18 but can be accessed through WebServer 18. Resource 24 is located on Web Server 18. A resource can beanything that is possible to address with a uniform resource locator(URL see RFC 1738). A resource can include a web page, softwareapplication, file, database, directory, a data unit, etc. In oneembodiment, a resource is anything accessible to a user on a network.The network could be the Internet, a LAN, a WAN, or any other type ofnetwork. Table 1, below, provides examples of resources and at least aportion of their respective URL syntax: Resource URL Encoding Directory/Sales/ HTML Page /Sales/Collateral/index.html CGI Script with no query/cgi-bin/testscript.cgi CGI Script with query/cgi_bin/testscript.cgi?button=on Application /apps/myapp.exe

A URL includes two main components: a protocol identifier and a resourcename separated from the protocol identifier by a colon and two forwardslashes. The protocol identifier indicates the name of the protocol tobe used to fetch the resource. Examples includes HTTP, FTP, Gopher, Fileand News. The resource name is the complete address to the resource. Theformat of the resource name depends on the protocol. For HTTP, theresource name includes a host name, a file name, a port number(optional) and a reference (optional). The host name is the name of themachine on which the resource resides. The file name is the path name tothe file on the machine. The port number is the number of the port towhich to connect. A reference is a named anchor within a resource thatusually identifies a specific location within a file. Consider thefollowing URL: “http://www.oblix.com/oblix/sales/index.html.” The string“http” is the protocol identifier. The string “www.oblix.com” is thehost name. The string “/oblix/sales/index.html” is the file name.

A complete path, or a cropped portion thereof, is called a URL prefix.In the URL above, the string “/oblix/sales/index.html” is a URL prefixand the string “/oblix” is also a URL prefix. The portion of the URL tothe right of the host name and to the left of a query string (e.g. tothe left of a question mark, if there is a query string) is called theabsolute path. In the URL above, “/oblix/sales/index.html” is theabsolute path. A URL can also include query data, which is typicallyinformation following a question mark. For example, in the URL:

http://www.oblix.com/oblix/sales/index.html?user=smith&dept=sales thequery data is “user=smith&dept=sales.” Although the discussion hereinrefers to URLs to identify a resource, other identifiers can also beused within the spirit of the present invention.

FIG. 1 shows Web Server 18 including Web Gate 28, which is a softwaremodule. In one embodiment, Web Gate 28 is a plug-in to Web Server 18.Web Gate 28 communicates with Access Server 34. Access Server 34communicates with Directory Server 36.

Administration Server 20 is a web-enabled server. In one embodiment,Administration Server 20 includes Web Gate 30. Other embodiments ofAdministration Server 20 do not include Web Gate 30. AdministrationServer 20 also includes other software modules, including User Manager38, Access Manager 40, and System Console 42. Directory Server 36 is incommunication with User Manager 38, Access Manager 40, System Console42, and Access Server 34. Access Manager 40 is also in communicationwith Access Server 34.

The system of FIG. 1 is scalable in that there can be many Web Servers(with Web Gates), many Access Servers, and multiple AdministrationServers. In one embodiment, Directory Server 36 is an LDAP DirectoryServer and communicates with other servers/modules using LDAP over SSL.In other embodiments, Directory Server 36 can implement other protocolsor can be other types of data repositories.

The Access Management System includes Access Server 34, Web Gate 28, WebGate 30 (if enabled), and Access Manager 40. Access Server 34 providesauthentication, authorization, and auditing (logging) services. Itfurther provides for identity profiles to be used across multipledomains and Web Servers from a single web-based authentication(sign-on). Web Gate 28 acts as an interface between Web Server 18 andAccess Server 34. Web Gate 28 intercepts requests from users forresources 22 and 24, and authorizes them via Access Server 34. AccessServer 34 is able to provide centralized authentication, authorization,and auditing services for resources hosted on or available to Web Server18 and other Web Servers.

Access Manager 40 allows administrators access to manage multipleresources across an enterprise and to delegate policy administration tothe persons closest to specific business applications and content. Inone embodiment, administrators perform these tasks using an intuitivegraphical user interface (“GUI”).

User Manager 38 provides a user interface for administrators to use,establish and/or manage identity profiles. An identity profile (alsocalled a user profile or user identity profile) is a set of informationassociated with a particular user. The data elements of the identityprofile are called attributes. In one embodiment, an attribute mayinclude a name, value and access criteria. In one embodiment, anidentity profile stores the following attributes: first name, middlename, last name, title, email address, telephone number, fax number,mobile telephone number, pager number, pager email address,identification of work facility, building number, floor number, mailingaddress, room number, mail stop, manager, direct reports, administrator,organization that the user works for, department number, department URL,skills, projects currently working on, past projects, home telephone,home address, birthday, previous employers and anything else desired tobe stored by an administrator. Other information can also be stored. Inother embodiments, less or more than the above-listed information isstored.

System Console 42 provides a GUI for administrators to perform varioustasks such as managing Administration roles, managing various systemwide settings, and configuring the Identity and Access ManagementSystems. System Console 42 can be used to manage groups (optional) anddeparting users, reclaim unused resources, manage logging, configureparameters for authentication, configure parameters for authorization,and so on. Additionally, System Console 42 can be used to configure userschemes and control access to certain Identity Management Systemcapabilities (such as “new user,” “deactivate user,” “workflow,” and soon).

The system of FIG. 1 is used to protect a web site, network, Intranet,Extranet, etc. To understand how the system of FIG. 1 protects a website (or other structure), it is important to understand the operationof unprotected web sites. In a typical unprotected web site, end userscause their browsers to send a request to a Web Server. The request isusually an HTTP request which includes a URL. The Web Server thentranslates, or maps, the URL into a file system's name space and locatesthe matching resource. The resource is then returned to the browser.

With the system of FIG. 1 deployed, Web Server 18 (enabled by Web Gate28, Access Server 34, and Directory Server 36) can make informeddecisions based on default and/or specific rules about whether to returnrequested resources to an end user. The rules are evaluated based on theend user's profile, which is managed by the Identity Management System.In one embodiment of the present invention, the general method proceedsas follows. An end user enters a URL or an identification of a requestedresource residing in a protected policy domain. The user's browser sendsthe URL as part of an HTTP request to Web Server 18. Web Gate 28intercepts the request. If the end user has not already beenauthenticated, Web Gate 28 causes Web Server 18 to issue a challenge tothe browser for log-on information. The received log-on information isthen passed back to Web Server 18 and on to Web Gate 28. Web Gate 28 inturn makes an authentication request to Access Server 34, whichdetermines whether the user's supplied log-on information is authenticor not. Access Server 34 performs the authentication by accessingattributes of the user's profile and the resource's authenticationcriteria stored on Directory Server 36. If the user's supplied log-oninformation satisfies the authentication criteria, the process flows asdescribed below; otherwise, the end user is notified that access to therequested resource is denied and the process halts. After authenticatingthe user, Web Gate 28 queries Access Server 34 about whether the user isauthorized to access the resource requested. Access Server 34 in turnqueries Directory Server 36 for the appropriate authorization criteriafor the requested resource. Access Server 34 retrieves the authorizationcriteria for the resource and, based on that authorization criteria,Access Server 34 answers Web Gate 28's authorization query. If the useris authorized, the user is granted access to the resource; otherwise,the user's request is denied. Various alternatives to the abovedescribed flow are also within the spirit and scope of the presentinvention.

In one embodiment, the system of FIG. 1 includes means for providing andmanaging identity profiles, and means for defining and managingauthentication and authorization policies. In one implementation, useridentity and authentication/authorization information is administeredthrough delegable Administration roles. Certain users are assigned toAdministration roles, thus conferring to them the rights andresponsibilities of managing policy and/or user identities in specificportions of the directory and web name spaces. The capability todelegate Administration duties enables a site to scale administrativelyby empowering those closest to the sources of policy and userinformation with the ability to manage that information.

A role is a function or position performed by a person in anorganization. An administrator is one type of role. In one embodiment,there are at least five different types of administrators: SystemAdministrator, Master Access Administrator, Delegated AccessAdministrator, Master Identity Administrator, and Delegated IdentityAdministrator. A System Administrator serves as a super user and isauthorized to configure the system deployment itself and can manage anyaspect of the system.

A Master Access Administrator is assigned by the system administratorand is authorized to configure the Access Management System. The MasterAccess Administrator can define and configure Web Gates, Access Servers,authentication parameters, and policy domains. In addition, MasterAccess Administrators can assign individuals to Delegated AccessAdministrator roles. A Delegated Access Administrator is authorized tocreate, delete and/or update policies within their assigned policydomain (described below), and create new policy domains subordinate totheir assigned policy domains. A Delegated Access Administrator may alsoconfer these rights to others. A Master Identity Administrator, assignedby the System Administrator, is authorized to configure the IdentityManagement System, including defining and configuring end useridentities and attributes, per attribute access control, who may performnew user and deactivate (revocation) user functions. Master IdentityAdministrators may also designate individuals to Delegate IdentityAdministrator roles. A Delegated Identity Administrator is selectivelyauthorized to perform new user and deactivate user functions.

A policy domain is a logical grouping of Web Server host ID's, hostnames, URL prefixes, and rules. Host names and URL prefixes specify thecourse-grain portion of the web name space a given policy domainprotects. Rules specify the conditions in which access to requestedresources is allowed or denied, and to which end users these conditionsapply. Policy domains contain two levels of rules: first level defaultrules and second level rules contained in policies. First level defaultrules apply to any resource in a policy domain not associated with apolicy.

A policy is a grouping of a URL pattern, resource type, operation type(such as a request method), and policy rules. These policy rules are thesecond level rules described above. There are two levels of rulesavailable (first and second levels) for authentication, authorization,and auditing. Policies are always attached to a policy domain andspecify the fine-grain portion of a web name space that a policyprotects. In practice, the host names and URL prefixes from the policydomain the policy belongs to are logically concatenated with thepolicy's URL pattern and the resulting overall patterns compared to theincoming URL. If there is a match, then the policy's various rules areevaluated to determine whether the request should be allowed or denied;if there is not a match, then default policy domain rules are used.

FIG. 2 illustrates a high level block diagram of a computer system whichcan be used for the components of the present invention. The computersystem of FIG. 2 includes a processor unit 50 and main memory 52.Processor unit 50 may contain a single microprocessor, or may contain aplurality of microprocessors for configuring the computer system as amulti-processor system. Main memory 52 stores, in part, instructions anddata for execution by processor unit 50. If the system of the presentinvention is wholly or partially implemented in software, main memory 52can store the executable code when in operation. Main memory 52 mayinclude banks of dynamic random access memory (DRAM) as well as highspeed cache memory.

The system of FIG. 2 further includes a mass storage device 54,peripheral device(s) 56, user input device(s) 60, portable storagemedium drive(s) 62, a graphics subsystem 64 and an output display 66.For purposes of simplicity, the components shown in FIG. 1 are depictedas being connected via a single bus 68. However, the components may beconnected through one or more data transport means. For example,processor unit 50 and main memory 52 may be connected via a localmicroprocessor bus, and the mass storage device 54, peripheral device(s)56, portable storage medium drive(s) 62, and graphics subsystem 64 maybe connected via one or more input/output (I/O) buses. Mass storagedevice 54, which may be implemented with a magnetic disk drive or anoptical disk drive, is a non-volatile storage device for storing dataand instructions for use by processor unit 50. In one embodiment, massstorage device 54 stores the system software for implementing thepresent invention for purposes of loading to main memory 52.

Portable storage medium drive 62 operates in conjunction with a portablenon-volatile storage medium, such as a floppy disk, to input and outputdata and code to and from the computer system of FIG. 2. In oneembodiment, the system software for implementing the present inventionis stored on such a portable medium, and is input to the computer systemvia the portable storage medium drive 62. Peripheral device(s) 56 mayinclude any type of computer support device, such as an input/output(I/O) interface, to add additional functionality to the computer system.For example, peripheral device(s) 56 may include a network interface forconnecting the computer system to a network, a modem, a router, etc.

User input device(s) 60 provide a portion of a user interface. Userinput device(s) 60 may include an alpha-numeric keypad for inputtingalpha-numeric and other information, or a pointing device, such as amouse, a trackball, stylus, or cursor direction keys. In order todisplay textual and graphical information, the computer system of FIG. 2includes graphics subsystem 64 and output display 66. Output display 66may include a cathode ray tube (CRT) display, liquid crystal display(LCD) or other suitable display device. Graphics subsystem 64 receivestextual and graphical information, and processes the information foroutput to display 66. Additionally, the system of FIG. 2 includes outputdevices 58. Examples of suitable output devices include speakers,printers, network interfaces, monitors, etc.

The components contained in the computer system of FIG. 2 are thosetypically found in computer systems suitable for use with the presentinvention, and are intended to represent a broad category of suchcomputer components that are well known in the art. Thus, the computersystem of FIG. 2 can be a personal computer, workstation, server,minicomputer, mainframe computer, or any other computing device. Thecomputer can also include different bus configurations, networkedplatforms, multi-processor platforms, etc. Various operating systems canbe used including Unix, Linux, Windows, Macintosh OS, Palm OS, and othersuitable operating systems.

FIG. 3 is a block diagram of Directory Server 36. Directory Server 36stores user identity profiles 102. Each identity profile includes a setof attributes for the particular end users. Group information 104 isalso stored, which describes logical relationships and groupings ofusers having identity profiles 102 stored on Directory Server 36. Aplurality of policies 106, each of which is associated with a policydomain as described above, are also stored on Directory Server 36.Revoked user list 108 identifies users previously (but no longer)allowed access to resources on their system. Shared secret(s) 110 arekeys stored on Directory Server 36 used for encrypting cookies set onbrowsers 12 or 14 after a successful user authentication. Sharedsecret(s) (keys) 110 can change as often as desired by an administrator.In one embodiment of the present invention, previously valid keys are“grandfathered” such that both a current key and an immediately priorkey will de-crypt encrypted cookies. Global sequence number (GSN) 112 isa unique number stored on Directory Server 36 which is assigned to apolicy domain change (first level default rules) or policy change(second level resource-specific rules) and updated in response tosubsequent policy changes for cache flushing purposes. In one embodimentof the present invention, the GSN is incremented to the next sequentialnumber after detection of a policy domain or policy change. Userattribute list 114 is a list of user identity profile attributes used bycached authentication and authorization rules.

FIG. 4 depicts an exemplar directory tree that can be stored onDirectory Server 36. Each node on the tree is an entry in the directorystructure. Node 130 is the highest node on the tree and represents anentity responsible for the directory structure. In one example, anentity may set up an Extranet and grant Extranet access to manydifferent companies. The entity setting up the Extranet is node 130.Each of the companies with Extranet access would have a node at a levelbelow node 130. For example, company A (node 132) and company B (node134) are directly below node 130. Each company may be broken up intoorganizations. The organizations could be departments in the company orlogical groups to help manage the users. For example, FIG. 4 showscompany A broken up into two organizations: organization A with node 136and organization B with node 138. Company B is shown to be broken upinto two organizations: organization C with node 140 and organization Dwith node 142. FIG. 4 shows organization A having two end users:employee 1 with node 150 and employee 2 with node 152. Organization B isshown with two end users: employee 3 with node 154 and employee 4 withnode 156. Organization C is shown with two end users: employee 5 withnode 158 and employee 6 with node 160. Organization D is shown with twoend users: employee 7 with node 162 and employee 8 with node 164.

Each node depicted in FIG. 4 can include one or more identity profilesstored in Directory Server 36. In one embodiment, there are differenttypes of object-oriented classes for storing information for eachidentity profile. One exemplar class pertains to entities such as entity130, company A (node 133), and company B (node 134). A second exemplarclass stores information about organizational units such as organizationA (node 136), organization B (node 138), organization C (node 140), andorganization D (node 142). In one embodiment, each of the organizationsare departments in a company and each of the users are employees whowork for that particular organization. A third exemplar class is forindividual persons such as employee 1 (node 150), employee 2, (node152), . . . employee 8 (node 164). Although the directory tree isdepicted as having three levels, more or less than three levels can beused.

In a typical use of the Identity Management System shown in FIG. 4, asource from the Identity Management System attempts to access a targetin the Identity Management System. For example, employee 1 (node 150)may seek to access the profile for employee 4 (node 156). Thus, node 150is the source and node 156 is the target. For efficiency purposes, oneembodiment stores access information at the target and at the highestlevel for targets with common access rules. In some cases, accessinformation is stored at a higher level even if a lower level does notinclude common access rules.

FIG. 5 is a flow chart describing the process for setting up an identityprofile by an administrator having authority to do so. In step 200, theadministrator selects the object class to be used for the directoryentry or entries being created. As previously described, there are atleast three classes: organization, organizational unit, and user. Instep 200, the master identity administrator selects which class is to beused for the entry. After the object class is selected in step 200, allpossible attributes for the particular class appear on a graphical userinterface (GUI) (step 202). In step 204, the administrator selects oneof the attributes. In step 206, the master identity administrator editsthe access criteria for the attribute. In step 210, it is determinedwhether there are any more attributes to consider. If so, the methodloops back to step 204. Otherwise, the process of FIG. 5 is completed(step 214).

FIG. 6 is a flow chart describing step 206 of FIG. 5, editing accesscriteria for an attribute. In step 230, the administrator selects wherein the tree structure of FIG. 4 to store the access information for theparticular attribute under consideration. For example, if theadministrator is setting up an identity profile for employee 2 (node152) of FIG. 4, attribute access information can be stored at node 152,node 136, node 132, or node 130. In step 230, it is determined which oneof those available nodes will store the information. In step 232, thepermissions to modify the attribute are set up using a policy. A policycan identify person(s) who can modify the attribute. The policy canidentify a set of people by identifying a role, by identifying a rulefor identifying people, by identifying one or more people directly byname, or by identifying a named group. In step 236, permissions are setup to determine who can view the attributes. The Identity ManagementSystem policy determines which users can view identity profileattributes by defining a role, defining a rule, identifying persons byname, or listing an identified group. In one embodiment, the rulementioned above is an LDAP rule. In step 238 (an optional step), theability to edit the permissions are delegated to others. In step 240, anotify list is set up. The notify list identifies a set of zero or morepersons who are notified (e.g. by email) when the attribute is modified.

In one embodiment, the Identity Management System includes a localizedaccess feature. This feature restricts certain user's access to identityprofiles within a defined locale. For example, if an entity sets up anExtranet similar to the tree of FIG. 4, and allows two of its suppliers(e.g. company A and company B) to access the Extranet, company A may notwant employees from company B to access identity profiles for employeesof company A. In accordance with the present invention, a set ofidentity profiles can be defined as a locale. Users outside the localecan be restricted from accessing identity profiles inside the locale.Alternatively, users outside the locale can be restricted from accessingcertain attributes of identity profiles inside the locale. The localizedaccess feature can be used to prevent any nodes, including node 132 andany nodes below node 132, from accessing node 134 and any node belownode 134. The localized access feature can be used at other levels ofgranularity and/or at other levels of the organizational hierarchy. Forexample, users below node 136 can be blocked from accessing profilesbelow node 138, node 140, node 142, node 134, etc.

FIG. 7 is a flow chart describing the process for configuring localizedaccess. In step 262, a localized access parameter for the entire systemof FIG. 1 is set. This parameter turns on the localized access function.In step 266 of FIG. 7, a class attribute can be set for localizedaccess. Each identity profile has a set of attributes. One of thoseattributes is designated as the class attribute. The class attribute isused to identify the identity profile. A reference to a particularidentity profile is a reference (or pointer) to the class attribute forthe identity profile. The class attribute can be configured forlocalized access by setting up a localized access filter that identifiesthe locale. If the source of a request is in a different locale than thelocale defined for the class attribute, then the source is denied accessto the target. The localized access filter can be an absolute test suchas “Company=Acme” or the filter can name another attribute (called adomain attribute). If the filter names a domain attribute (e.g. companyattribute, address attribute, last name attribute, organizationattribute, etc.), then the filter is satisfied if the named attributefor source matches the named attribute for the target. For example, ifthe domain attribute named for the class attribute is “Company Name,”than a source can only access a target if the company name for thesource is the same as the company name for the target. Using a domainattribute, rather than hard coding the criteria, is more dynamic becauseit depends on the run-time relationship of the source and target. In oneembodiment, multiple domain attributes can be used to define the locale.Users whose domain attributes are equal, are in the same locale. A usercan be a member of multiple locales.

In step 268, individual attributes for a profile can be configured forlocalized access. That is, some attributes in an identity profile can beconfigured for localized access, while other attributes are not. Eachattribute can be provided with a localized access filter that identifiesthe locale for that attribute. The localized access filter can includean absolute test, an LDAP test or one or more domain attributes. In oneembodiment, individual attributes are not configured in step 268 if theclass attribute for the profile has already been set. It is possible toconfigure the class attribute for localized access and not configure theother attributes for localized access. Similarly, in some embodiments itis possible to not configure the class attribute for localized accesswhile configuring the other attributes for localized access.

In one embodiment, when a source seeks to access a particular attributein a target, the system first checks to see if the localized accessfilter for the class attribute of the target is satisfied. If it is notsatisfied, then access is denied. If it is satisfied, then the systemfirst checks to see if the localized access filter for the particularattribute of the target is satisfied. If it is or it is not configuredfor localized access, then access can be granted. If the localizedaccess filter for the particular attribute of the target is notsatisfied, access to the particular attribute is denied. In summary, thelocalized access filter for the class attribute determines access to theentire identity profile, while the localized access filter for aspecific attribute (other than the class attribute) determines access tothe specific attribute. After the steps of FIG. 7 are completed, theprofiles (or portions of profiles) that have been set for localizedaccess can only be accessed by those within the same locale.

FIG. 8 is a flow chart describing the process for accessing data in theIdentity Management System. The data can be accessed for viewing,modifying, etc. As described above, the entity attempting to access aprofile in the Identity Management System is the source and the profilebeing accessed is the target. In step 290, the source user's browsersends a request to access attributes of a target directory entry. Instep 292, the request is received by User Manager 38. In step 294, UserManager 38 accesses the target profile and the source profile onDirectory Server 36. In step 296, User Manager 38, based on theattribute settings created or modified by the process of FIG. 5 and(possibly) the source profile, determines whether the source should haveaccess to each of the different attributes of the target profile. Thisstep is discussed in further detail below. In step 298, User Manager 38passes the information for the attributes that access is allowed for tothe source's browser. In step 300, the attributes that the source mayview are displayed on the source's browser.

FIG. 9 is a flow chart describing the process of step 296 of FIG. 8,determining whether the source should have access to the variousattributes of the target. In step 320, the system determines whether alocalized access violation for the class attribute has occurred. Alocalized access violation is found when the target's class attribute isconfigured for localized access and the source is not in the locale forthe target. If there is a localized access violation, the method of FIG.9 is done (step 344) and none of the attributes for the target may beaccessed by the source. For example, if the source is employee 1 (node150 of FIG. 4), the target is employee 8 (node 164 of FIG. 4), and allof company B is subject to localized access with a domain attribute setas “company ”(in one embodiment the actual syntax is %company%) alocalized access violation will be found in step 320.

If no localized access violation is found in step 320, then one of theattributes for the target is selected in step 322 and User Manager 38determines whether the access information for that selected attribute isat the current level in the tree. The first time step 324 is performed,the current level in the tree is the level of the target. As previouslyexplained, access information can be stored at the target's node ornodes above the target. If the access information is not found at thecurrent level, then in step 340, it is determined whether the system isinquiring at the top level of the directory structure (e.g. node 130 ofFIG. 4). If the system is at the top level, then the system determineswhether all attributes have been evaluated in step 332. If allattributes have been evaluated, then the process of FIG. 9 is done (step348). If all attributes have not been evaluated, then the systemaccesses the initial level again in step 334 and loops back to step 322.If in step 340, it is determined that the system is not at the toplevel, then the system moves up one level (step 342) and loops back tostep 324.

While in step 324, if the access information for the attribute is at thecurrent level being considered, then in step 326 it is determinedwhether there is a local access violation for the attribute underconsideration. If the particular attribute being considered wasconfigured for localized access and the source is not in the relevantlocale for the target, then a localized access violation occurs and themethod of FIG. 9 is done (step 346). It will be appreciated thatlocalized access can apply to entire profiles or only certain portions(certain attributes) of profiles. If the attribute under considerationwas not configured for localized access, then there is no localizedaccess violation for the attribute under consideration. If there is nolocalized access violation for the attribute under consideration, thenthe identity profile for the source is applied to any additional accesscriteria to see whether the source should have access to the target'sattribute. If the criteria is met, access is granted in step 330 and themethod loops to step 332. At the end of the process of FIG. 9, a sourcewill be granted access to zero or more attributes. Step 300 of FIG. 8displays only those attributes for which the source has been grantedaccess.

FIG. 10 is a flow chart describing the process of step 320 in FIG. 9,determining whether a localized access violation has occurred for aclass attribute. In step 360, the Identity Management System determineswhether the localized access parameter is set. If not, there is nolocalized access violation. If so, then in step 364, the systemdetermines whether a class attribute is configured for localized access.If the class attribute is not configured for localized access, there isno local access violation (step 362). If the class attribute isconfigured for localized access, then in step 366 it is determinedwhether the localized access filter is satisfied (e.g. does the domainattribute for the target must match the domain attribute for thesource?). If the localized access filter is satisfied, no localizedaccess violation occurs (step 362). If the localized access filter isnot satisfied, then a localized access violation exists and accessshould be denied (step 368).

FIG. 11 is a flow chart describing the process performed in step 326 ofFIG. 9, determining whether there is a localized access violation for aparticular attribute. In step 380, it is determined whether a localizedaccess parameter is set. If not, there is no localized access violation(step 382). Otherwise, in step 384, it is determined whether theparticular attribute is configured for localized access. If theparticular attribute is not configured for localized access, then thereis no localized access violation (step 382). If the particular attributeis configured for localized access, then in step 386 it is determinedwhether the localized access filter for the attribute underconsideration is satisfied. If the localized access filter is satisfied,then there is no localized access violation (step 382). If the localizedaccess filter is not satisfied, then there is a localized accessviolation and access should be denied (step 388).

FIG. 12 is a flow chart describing the process of how a source user canmodify an attribute of a target profile. In step 410, the source userattempts to modify an attribute. For example, in one embodiment thesource user is provided a GUI which depicts the directory tree. Thesource user can select any node in the directory tree and click on abutton to modify a target profile. Alternatively, the source user cantype in a URL, distinguished name, or other identifying information forthe target. Once presented with a target profile (e.g. the process ofFIG. 8), the user selects a particular attribute and attempts to modifyit by selecting a modify button on the GUI. This request to modify issent to User Manager 38. In step 412, User Manager 38 searches for themodify criteria for the attribute in the target directory. This modifycriteria is the information set up in step 232 of FIG. 6. User Manager38 searches in the current target directory. If the criteria is notfound in the current directory being accessed (see step 414), then it isdetermined whether the system is at the top of the directory treestructure (step 416). If not, then the system moves up one level in step418. If the top of the directory structure is reached, then the sourceuser is not allowed to modify the attribute (step 420). In step 422,User Manager 38 searches for the modify criteria in a new directory.After step 422, the method loops back to step 414. If in step 414, it isdetermined that the criteria was found at the current level beingconsidered, then in step 430, the User Manager evaluates the criteriaagainst the target user's identity profile. If the identity profile forthe target user satisfies the criteria for modifying the attribute (step432) then the source user is allowed to modify the attribute (step 434).Otherwise, the source user is not allowed to modify the attribute (step420).

FIG. 13 is a flow chart describing a process for automating the updatingof identity profiles when a source user requesting the update is notallowed to modify the target profile. In one embodiment, the source useris the person identified by the target profile. In step 450, the sourceuser requests modification of the target profile. This can be a requestto modify any or all of the attributes for the target profile (e.g.address, telephone number, creation of the profile, deletion of theprofile, etc.). In step 452, it is determined whether the target profileis protected. It is possible to set all attributes such that any sourceentity can modify the attributes In such a configuration; the profile isnot protected. If the target profile is not protected, then, in step454, the target profile is modified as per the source user's request. Ifthe target profile is protected, then in step 456, the User Manager 38issues an electronic message (“ticket”) sent to a responsible partyrequesting that the modification be made. The responsible party is aperson granted access to modify a particular attribute and has theresponsibility for doing so. In step 458, the ticket appears in aservice queue accessible by the responsible party. The service queue canbe a directory which stores all tickets or can be any database which isused to store the tickets. The responsible party may access a GUI whichindicates all tickets in the service queue, the date they were received,and what service is requested. In step 460, the requesting source usercan view whether a ticket has been serviced. In step 462, the ticket isfully serviced, partially serviced or denied by the responsible party.If the ticket is serviced, then the target will be modified. However,the target will not be modified if the ticket is denied. After thetarget is modified (or purposely not modified) and a ticket is respondedto, the ticket is removed from the service queue in step 464. In anoptional embodiment, the source is automatically notified that theticket is removed from the service queue and notified of the result ofthe request.

FIG. 14 provides a block diagram of Web Gate 28. In one embodiment, WebGate 28 is a Web Server plug-in running on Web Server 18. In anotherembodiment, Web Gate 28 is an NSAPI Web Server plug-in. In anotherembodiment, Web Gate 28 is an ISAPI Web Server plug-in. In still afurther embodiment, Web Gate 28 is an Apache Web Server plug-in. Inanother embodiment, a plurality of Web Gates conforming to differentplug-in formats are distributed among multiple Web Servers.

Resource cache 502 caches authentication information for individualresources. The information stored in resource cache 502 includes:request method, URL, retainer 505, and audit mask 503. In one embodimentof the present invention, audit mask 503 is a four bit data structurewith separate bits identifying whether authentication and/orauthorization successes and/or failures are audited (logged) for a givenresource.

Authentication scheme cache 506 stores authentication schemeinformation, including information necessary for the performance of eachdifferent authentication challenge scheme. For example, if theauthentication scheme ID parameter of a resource cache 502 entryreferences a “client certificate” authentication scheme, then theauthentication scheme ID parameter of the entry would reference anauthentication scheme cache 506 entry (keyed by the authenticationchallenge method ID). In one embodiment, authentication scheme cachestores redirect URL, authentication challenge method ID (identifying anauthentication challenge method), challenge parameters forauthentication and authentication level. Web Gate 28 also stores themost recent global sequence number 510 received from Access Server 34pursuant to a cache flushing operation, as further described below.

Event manager 514 calls redirection event handler 504, resourceprotected event handler 508, authentication event handler 512, orauthorization event handler 516 to perform redirection, a resourceprotected method, an authentication method, or an authorization method(all further described herein), respectively. Redirection event handler504 redirects browser 12 or 14 in response to redirection eventsinitiated by Access Server 34 or other components of Web Gate 28.Resource protected event handler 508 performs steps in a method fordetermining whether a requested resource falls protected within a policydomain. Authentication event handler 512 performs steps in a method forauthenticating a user of browser 12 or 14 upon a finding that arequested resource is protected. Authorization event handler 516performs steps in a method for determining whether a user of browser 12or 14 is authorized to access a requested resource upon a successfulauthentication or receipt of a valid authentication cookie, furtherdescribed herein. Sync record table 518 identifies all existingsynchronization records not yet processed by Web Gate 28 as furtherdescribed herein.

FIG. 15 provides a block diagram of Access Server 34. Authenticationmodule 540 is provided for carrying out steps in a method forauthenticating a user as further described herein. Authorization module542 is provided for carrying out steps in a method for authorizing auser to access a requested resource as further described herein.Auditing module 544 carries out steps in a method for auditing (logging)successful and/or unsuccessful authentications and/or authorizations asfurther described herein. Audit logs 546 store information logged byauditing module 544 in accordance with the present invention. Audit logssensors 548 include one or more sensors that monitor the audit logs forcertain types of events. Synchronization records 550 are stored onAccess Server 34 in accordance with a method for flushing caches asfurther described herein.

Access Server 34 stores the most recent global sequence number 554received from Access Manager 40 pursuant to a cache flushing operation.URL prefix cache 564 stores the URL prefixes associated with policydomains that are protected by the Access Management System. URL prefixcache 564 facilitates the mapping of requested resources to policydomains, as further described herein. URL prefix cache 564 is loadedfrom Directory Server 36 upon initialization of Access Server 34.

Policy domain cache 566 caches all default authentication rules of eachpolicy domain in accordance with the present invention. Policy domaincache further stores an array of rules 565 listing all default andresource-specific rules associated with resources in a given policydomain. Each rule entry in array 565 includes the ID of the rule andcompiled information about the URL pattern (resource) to which the ruleapplies. Array 565 enables Access Server 34 to quickly find the firstlevel default authentication, authorization, and auditing rules for agiven policy domain, as well as second level rules (authentication,authorization, and auditing rules) associated with particular policiesin the policy domain.

Authentication scheme cache 568 caches information necessary for theperformance of different authentication challenge methods as similarlydescribed above for authentication scheme cache 506 of Web Gate 28.Authentication rule cache 570 caches second level authentication rulesassociated with policies. The rules in authentication rule cache 570 arelisted in array 565. Upon determining that a second level authenticationrule exists and learning its ID (by looking in array 565), Access Server34 can easily find the second level authentication rule inauthentication rule cache 570. The second level rules are the rulesassociated with policies, discussed above.

Authorization rule cache 572 caches first level default authorizationrules as well as second level authorization rules. The rules inauthorization rule cache 572 are listed in array 565. Upon determiningthat a first or second level authorization rule exists and learning itsID (by looking in array 565), Access Server 34 can easily find theapplicable authorization rule for a given resource in authorization rulecache 572.

Audit rule cache 574 caches first level default audit rules as well assecond level audit rules. The rules in audit rule cache 574 are listedin array 565. Upon determining that a first or second level audit ruleexists and learning its ID (by looking in array 565), Access Server 34can easily find the applicable audit rule for a given resource in auditrule cache 574.

User profile cache 576 stores identity profile attributes previouslyused in authentications, authorization, or audit steps, in accordancewith the present invention. User policy cache 578 stores the successfuland unsuccessful authorization results for specific users requestingspecific resources governed by authorization rules based on an LDAPfilter or a group membership. User policy cache 578 allows Access Server34 to quickly recall a user's authorization if the user has recentlyaccessed the resource.

FIG. 16 is a flow chart which describes the process of creating a policydomain. In step 600, System Console 42 (or Access Manager 40) receives arequest to create a policy domain. In step 602, the name of the policydomain and the description of the policy name are stored. In step 604,one or more URL prefixes are added to the policy domain. In step 605,one or more host ID's are added to the policy domain (optional). Next,one or more access rules are added to the policy domain. An access ruleis a rule about accessing a resource. Examples of access rules includeauthorization rules, authentication rules, auditing rules, and otherrules which are used during the process or attempting to access aresource. In step 606, a first level (default) authentication rule isadded to the policy domain. In general, authentication is the process ofverifying the identity of the user. Authentication rules specify thechallenge method by which end users requesting access to a resource inthe policy domain must prove their identity (authentication). Aspreviously discussed, first level (default) authentication rules applyto all resources in a policy domain, while second level authenticationrules are associated with policies that apply to subsets of resources orspecific resources in the policy domain. In one embodiment, there isonly one default authentication rule for a policy domain. If anadministrator desires an authentication rule to apply to only a specificresource in the policy domain, a separate policy for that specificresource having a second level (specific) authentication rule should bedefined, as discussed below. After setting up the authentication rule instep 606, one or more first level or default authorization rules areadded to the policy domain in step 608. In general, an authorizationrule determines who can access a resource. The default authorizationrule allows or denies users access to resources within its applicablepolicy domain. If multiple authorization rules are created, then theyare evaluated in an order specified in step 610. In step 612, a firstlevel (default) audit rule is configured for the policy domain. In step614, zero or more policies are added to the policy domain. In step 616,the data for the policy domain is stored in Directory Server 36 andappropriate caches (optional) are updated. In one embodiment, anauthorization rule or an authentication rule can be set up to take noaction. That is, always grant authentication without any challenge orverification; or always grant authorization without any verification.

FIG. 17 is a flow chart describing the process of adding one or moreauthorization rules to a policy domain (step 608 of FIG. 16). In step632, timing conditions are set up for the authorization rule. Timingconditions restrict the time when the authorization rule is in effect.For example, users can be allowed access to URLs in the policy domainonly during business hours, Monday through Friday. In one embodiment, iftiming conditions are not set, the authorization rule is always ineffect. The timing conditions include selecting a start date, an enddate, selecting a start time and an end time, selecting the months ofthe year, selecting the days of the month, and selecting the days of theweek that the rule is valid. In steps 634 and 636, authorization actionsare set up. Authorization actions personalize the end user's interactionwith the Web Server. In step 634, header variables are provided forauthorization success events and authorization failure events. Thisfeature allows for the passing of header variables about the end user(or other information) to other web-enabled resources. Web-enabledapplications can personalize the end user's interaction with the WebServer using these header variables. As a simple example, the actionscould supply each application with the user's name. An application couldthen greet the user with the message “hello <user's name >” whenever theuser logs on. Header variables are variables that are part of an HTTPrequest. FIG. 40 below illustrates the format of an HTTP request thatincludes header variables 1554. If an authorization rule is set up withheader variables as part of an authorization success action, then when asuccessful authorization occurs the HTTP request to the resource willinclude the header variables. Similarly, if there are header variablesfor an authorization failure, then an authorization failure event willinclude adding header variables to the HTTP request that redirects abrowser to an authorization failure web page. The resources identifiedby the HTTP requests, that include the header variables can use theheader variables any way desired. In one embodiment of the method ofFIG. 17, one or more groups can be specified for authorization to theresource(s).

FIG. 18 is a flow chart that describes the process of adding headervariables to an HTTP request (see step 634 of FIG. 17). Header variablescan be added during an authorization success event, authorizationfailure event, authentication success event or authentication failureevent. In step 650, the variable name is entered. In step 652, a textstring is entered. In step 654, one or more LDAP attributes are entered.In step 656, it is determined whether any more header variables will beadded. If not, the method of FIG. 18 is done (step 658). If so, themethod of FIG. 18 loops back to step 650.

The variable name entered in step 650 is a value that appears in theHTTP header that names the variable. The downstream resource using theheader variable will search for the variable name. The string entered isdata that can be used by the downstream resource. The LDAP attribute(s)can be one or more attributes from the requesting user's identityprofile. Thus, in the simple authorization success example describedabove, the variable name field can include “authorization success,” thereturn field can include “yes,” and the attribute field can include thename attribute for the user in the user's identity profile. Any of theattributes from the user's identity profile can be selected as a headervariable.

Looking back at FIG. 17, in step 636, a redirect URL can be added for anauthorization success event and a redirect URL can be entered for anauthorization failure event. Step 638 includes specifying which usersare allowed to access the resource associated with the authorizationrule. By default, users cannot access a resource until they are grantedaccess rights to it. In one embodiment, there are at least four meansfor specifying who can access a resource. The first means is toexplicitly name a set of users who can access the resource. A secondmeans includes identifying user roles. The third means is to enter anLDAP rule that can be used to identify a set of users based on acombination of one or more attributes. A fourth means is to enter an IPaddress which will allow users of computers having the specified IPaddress to access the resource. Step 640 is used to specify the usersnot allowed to access the resource associated with this rule.Identification of users, roles, LDAP rules, and IP addresses are enteredin step 640 in the same manner as entered in step 638. It is possiblethat a particular user can be subject to both an allow access rule and adeny access rule. Step 642 is used to set a priority between such rules.Optional step 644 is used to define any POST data to be used forauthorization if this feature is implemented. An HTTP POST request caninclude POST data in the body of the HTTP request (see FIG. 40 below).POST data can also be submitted in query string form. One embodiment ofthe present invention allows POST data to be used for authorizationpurposes. In optional step 644, an administrator defines which POST datais to be used for authorization purposes. If POST data is to be used forauthorization, in order for an authorization rule to be satisfied, thePOST request must include all the appropriate POST data and values forthat POST data as defined in step 644. However, it will be understoodthat POST data need not be used for authorization in all embodiments ofthe present invention. Step 646 is used to set a priority of evaluationfor the authorization rule relative to other authorization rules in agiven policy. In one embodiment, if multiple authorization rules applyto a resource, this priority determines the order of evaluation.

FIG. 19 is a flow chart describing the process for adding anauthentication rule (see step 606 of FIG. 16). In step 670, a challengescheme (also called an authentication scheme) is selected. Anauthentication scheme is a method for requesting log-on information(e.g. name and password) from end users trying to access a web resource.Within an authentication scheme is a challenge method (e.g. Basic,certificate or form). There can be more than one authentication schemewith the same challenge method (e.g. Basic over LDAP, Basic over NTDomain, . . . ). Various other authentication schemes can also be used.In step 672, header variables are added for authentication success andauthentication failure events. In step 674, redirect URLs are added forauthentication success events and authentication failure events.

FIG. 20 provides a flow chart depicting the process for configuring anaudit rule (see step 612 of FIG. 16). In step 680, the events to triggeran audit are selected. In one embodiment, authentication success,authentication failure, authorization success and authorization failurecan be selected for auditing. In step 682, the information to be loggedis selected for each particular event identified in step 680. Theinformation logged can include information about the event and/or userattributes from the identity profile for the user requesting theauthentication or authorization.

FIG. 21 is a flow chart describing the process of adding a policy (seestep 614 of FIG. 16). In step 718, a resource type is specified. Theresource type allows different resources to be handled by differentpolicies, depending on the nature of the resource itself. For example,in one embodiment, the resource type will distinguish between resourcesaccessed using HTTP and resources accessed using FTP. In anotherembodiment, Enterprise Java Beans (EJBs) are a possible resource type.In another embodiment, user-defined custom resource types are supported.In step 720, an operation type is specified. This allows differentresources to be handled by different policies, depending on theoperations used to request the resource. In one embodiment, theoperations will be HTTP requests. Supported HTTP request methods includeGET, POST, PUT, HEAD, DELETE, TRACE, OPTIONS, CONNECT, and OTHER. Inanother embodiment, if EJBs are identified as the resource type (step718), an EXECUTE operation can be specified in step 720. In anotherembodiment, user-defined custom operations are supported. In step 722, apattern for the URL path to which the policy applies is specified. Thisis the part of URL that does not include the scheme (“http”) andhost/domain (“www.oblix.com”), and appears before a ‘?’ character in theURL. In step 724, a query string is specified. This is a set ofvariables and values that must be included in the specified order in anincoming URL for the policy to match and be activated. For example, inthe URL “HTTP://www.zoo.com/animals.cgi?uid=maneaters&tigers=2” thevalues after the question mark (e.g. “uid=maneaters&tigers=2”) comprisea query string. Only a URL exhibiting the query string can match to thispolicy. For example, a URL with the “tigers” variable appearing beforethe “uid” variable will not match the above-identified policy. In step726, query string variables are added. Query string variables include aname of a variable and the variable's corresponding value. Query stringvariables are used when it is a desirable that multiple variables arefound in the query string, but the order is unimportant. Thus, for apolicy with query string variables “uid=maneaters” and “tigers=2,” a URLwith a query string having the appropriate uid and appropriate tigersvariable, in any order, will match the policy. In order for a resourceURL to apply to a policy, the path of the requested resource URL mustmatch the path of the policy as well as any query string or queryvariables. As discussed above, POST data can be submitted in querystring form (for example, in a form submission), and evaluated using thequery string variables entered in step 726.

The query string or query variables specified in the steps of FIG. 21 donot need to uniquely identify a resource. Rather, they are used toidentify a policy, which may apply to one or more resources.

Typically, the query data is added to a URL to access certain data froma resource. However, the query data can be used in the URL to identifythe resource. Each application or resource is free to use the query datain any way that is in agreement with standards and norms known in theart.

In step 728 of FIG. 21, the authentication rule is created in accordancewith the method of FIG. 19. In step 730, one or more authorization rulesare created for the policy in accordance with the method of FIG. 17. Instep 732, an audit rule for the policy is configured in accordance withthe method of FIG. 20. In step 734, POST data (optional) is added to thepolicy. This POST data is used to map resources with policies.

The present invention supports the use of multiple authenticationschemes. An authentication scheme comprises an authentication level, achallenge method, an SSL assertion parameter, a challenge redirectparameter, and authentication plug-ins. The authentication levelrepresents an arbitrary designation of the level of confidence that anadministrator has in a particular authentication scheme relative toother authentication schemes.

In one embodiment of the present invention, an authentication scheme canspecify one of four challenge methods: none, basic, form, and X.509. Ifan authentication scheme's challenge method is set to “none,” noauthentication is required to access a requested resource, thus allowingsupport for unauthenticated users. This challenge method can be usedover both unsecured as well as SSL connections. The “basic” challengemethod can also be used over both unsecured and SSL connections. The“X.509” challenge method can only be used over an SSL connection betweena user's browser and Web Server host, because the authentication methodinvoked for an X509 challenge method is part of the SSL protocol. A“form” challenge method employs a custom, site-specific HTML formpresented to the user, who enters information and submits the form.Subsequent processing is determined by the administrator at the time theauthentication scheme is created. Form challenge methods can be usedover both unsecured and SSL connections.

The SSL parameter of an authentication scheme identifies whether SSL isto be asserted on the connection to the user's browser by the WebServer. The challenge parameter identifies where to redirect a requestfor authentication for the particular authentication scheme.Authentication plug-ins are necessary for processing the user's suppliedinformation. Authentication plug-ins can interface with Access Server 34through an authentication API.

An authentication scheme that an attacker can easily and profitabilityeavesdrop upon is typically considered “weak.” In one embodiment, thebasic authentication challenge method places the user's credential(supplied information), a simple password, “in the clear” over anunsecured network connection. However, the authentication scheme can bemade stronger by passing the user's credential over an encryptedconnection, such as SSL. In one embodiment, given two authenticationschemes (one with and one without SSL), an access administrator willassign the authentication scheme without SSL to a lower authenticationlevel than the authentication using SSL.

When a user first request a protected resource, the user is challengedaccording to the authentication scheme defined by the fist levelauthentication rule in the applicable policy domain or the second levelauthentication rule in the applicable policy associated with therequested resource. If the user satisfies the authentication rule, anencrypted authentication cookie is passed to the user's browserindicating a successful authentication. Once authenticated, the user mayrequest a second resource protected by a different policy domain and/orpolicy with a different authentication rule. The user will be allowedaccess to the second resource without re-authenticating if theauthentication level of the authentication scheme used to successfullyauthenticate for the first resource is equal to or greater than theauthentication level of the authentication scheme of the secondresource. Otherwise, the user is challenged and asked to re-authenticatefor the second resource in accordance with the second resource's higherlevel authentication scheme. Satisfaction of a higher or lowerauthentication level is determined by evaluating the authenticationcookie sent by the user's browser when requesting the second resource.In one embodiment of the present invention, administrators can define anunlimited number of authentication levels.

Once authenticated, a user can explicitly log out, causingauthentication cookies cached (or otherwise stored) by the user'sbrowser to be destroyed or become invalid. Authentication cookies canalso be set by an administrator to be destroyed after a maximum idletime has elapsed between requests to resources protected in accordancewith the present invention.

FIG. 22 provides a flow chart for one embodiment of a method forauthenticating, authorizing, and logging. In step 750, a user's browser12 requests a web-enabled resource 22 or 24. The request is interceptedby Web Gate 28 in step 752. The method then determines whether therequested resource is protected by an authentication and/orauthorization rule in step 753. If the resource is not protected, thenaccess is granted to the requested resource in step 795. If therequested resource is protected however, the method proceeds to step754. If the user has previously authenticated for a protected resourcein the same domain, a valid authentication cookie will be passed bybrowser 12 with the request in step 750 and intercepted by Web Gate instep 752. If a valid cookie is received (step 754), the method attemptsto authorize the user in step 756. If no valid authorization cookie isreceived (step 754), the method attempts to authenticate the user forthe requested resource (step 760).

If the user successfully authenticates for the requested resource (step762), then the method proceeds to step 774. Otherwise, the unsuccessfulauthentication is logged in step 764. After step 764, the system thenperforms authentication failure actions and Web Gate 28 denies the useraccess to the requested resource in step 766. In step 774, thesuccessful authentication of the user for the resource is logged. Themethod then performs authentication success actions in step 766. Inresponse to the successful authentication, Web Gate 28 then passes avalid authentication cookie to browser 12 in step 780 which is stored bybrowser 12. After passing the cookie in step 780, the system attempts toauthorize in step 756.

In step 756, the method attempts to determine whether the user isauthorized to access the requested resource. If the user is authorized(step 790), the method proceeds to step 792. Otherwise, the unsuccessfulauthorization is logged in step 796. After step 796, the method performsauthorization failure actions (step 798) and Web Gate 28 denies the useraccess to the requested resource. If authorization is successful (step790), then the successful authorization of the user is logged in step792, authorization success actions are performed in step 794, and theuser is granted access to the requested resource in step 795. In oneembodiment of step 795, some or all of HTTP request information isprovided to the resource.

FIG. 23 provides a flow chart of a method for determining whether arequested resource is protected (see step 753 of FIG. 22). In oneembodiment, the steps of FIG. 23 are performed by resource protectedevent handler 508 and Access Server 34. In step 830, Web Gate 28determines whether an entry for the requested resource is found inresource cache 502. If an entry is found, the cache entry is examined instep 842 to determine whether the cache entry indicates that theresource is protected (step 832) or unprotected (step 840). If an entryfor the requested resource is not found in resource cache 502, then WebGate 28 passes the URL of the requested resource request method toAccess Server 34 in step 833. Access Server 34 attempts to map therequested resource to a policy domain using URL prefix cache 564 (step836).

If mapping step 836 is unsuccessful (step 838), then the requestedresource is deemed to be unprotected (step 840). However, if asuccessful mapping has occurred (step 838), then Access Server 34retrieves the authentication rule (step 844) and audit rule (step 846)associated with the requested resource. Access Server 34 then passes theauthentication scheme ID from the authentication rule, audit mask 503,retainer 505 and any POST data received to Web Gate 28 in step 848. WebGate 28 caches the authentication scheme ID from the authenticationrule, audit mask 503, retainer 505 and POST data in resource cache 502(step 850). Since the requested resource was successfully mapped to apolicy domain in step 836, the resource is deemed protected (step 832).

FIG. 24 is a flow chart describing the process for mapping a resource toa policy domain (see step 836 of FIG. 23). In step 900, Access Server 34receives the URL of the requested resource from Web Gate 28. AccessServer 34 then compares a URL prefix of the requested resource withentries in URL prefix cache 564 in step 902. In one embodiment, whenstep 902 is called for the first time in FIG. 24, the URL prefix of therequested resource equals the file name. Thus, if the URL of therequested resource reads: “http://www.oblix.com/oblix/sales/index.html”then the URL prefix first compared by step 902 will be:“/oblix/sales/index.html.” If a matching URL prefix is found (step 904),Access Server 34 proceeds to step 916.

In step 916, Access Server 34 determines whether the policy domainassociated with the matching URL prefix calls for one or more host ID's.In one embodiment, resources are mapped to certain policy domains if theport number of a resource request and the location of the resourceitself conform to one or more host ID's. Thus, multiple policy domainscan be associated with identical URL prefixes, each policy domainrequiring different host ID's (or none at all). If the policy domainconsidered in step 916 requires a matching host ID, then Access Server34 proceeds to step 917. Otherwise, Access Server 34 proceeds directlyto step 906 where the requested resource is mapped to the policy domainassociated with the currently considered URL prefix. In step 917, if amatching host ID is found, Access Server 34 proceeds to step 906. If nomatching host ID is found, Access Server 34 returns to step 904 where itdetermines whether additional matching URL prefixes exist.

If no matching URL prefix is found in step 904, then Access Server 34proceeds to step 908. In step 908, Access Server 34 crops the right-mostterm from the resource URL prefix compared in step 902. Thus, if theresource URL prefix compared in step 902 reads:“/oblix/sales/index.html” then the resource URL prefix will be croppedin step 908 to read: “/oblix/sales.” If the entire resource URL prefixhas been cropped in step 908 such that no additional terms remain (step910), then the method proceeds to step 912 where Access Server 34concludes that there is no policy domain associated with the requestedresource. However, if one or more additional terms remain in theresource URL prefix, then the method returns to step 902 where thecropped URL prefix is compared with URL prefixes cached in URL prefixcache 564.

As will be apparent from FIG. 24, the method recurses through steps 902,904, 908, and 910 until either a match is found (step 904) or the entireresource URL prefix has been cropped (step 910). In any case, the methodof FIG. 24 will inevitably return either a successful mapping (step 906)or no mapping (step 912).

FIG. 25 provides a flow chart describing a method for loading anauthentication rule (see step 844 of FIG. 23). In step 930, AccessServer 34 loads the first level (default) authentication rule for thepolicy domain mapped in step 836 of FIG. 23 from Directory Server 36into authentication rule cache 570. In one embodiment, success andfailure actions are part of all authentication and authorization rules.In one embodiment, Access Manager 40 maintains a user attribute list 114on Directory Server 36. User attribute list 114 identifies all userattributes used by authentication and authorization actions loaded intoauthentication rule cache 570 and authorization rule cache 572. In thisstep, Access Server 34 also builds array 565 (previously describedabove) and loads it into policy domain cache 566. Array 565 includes allsecond level rules and patterns associated with each of the policies forthe policy domain. Access Server 34 then selects a second level rule inarray 565 (step 931). The selected second level rule is part of apolicy. In step 932, Access Server 34 performs a pattern matching method(further described below) for determining whether the rule applies tothe requested resource. If so, then Access Server 34 proceeds to step935; otherwise, Access Server 34 determines whether all rules in array565 have been evaluated (step 933). If, in step 933, it is determinedthat not all of the rules in the array have been evaluated, then AccessServer 34 selects the next rule in array 565 (step 934) and returns tostep 932. Once all rules in array 565 have been considered (step 933),the first level authentication rule previously loaded in step 930 isreturned as the authentication rule, no second level authentication ruleis loaded into authentication rule cache 570, and the method of FIG. 25is done (step 937). If an associated policy was found in step 932, thenauthentication module 540 caches the second level authentication ruleand success and failure actions for the rule in authentication rulecache 570 (step 935), returns that second level authentication rule(step 936), and the method is done (step 937).

FIG. 26 is a flow chart describing a method for determining whether apolicy is associated with a resource (see step 932 of FIG. 25). A policyURL can contain the following three types of patterns. All three typesof patterns were referenced in FIG. 21:

1. Pattern on the path of the URL: This is the part of URL that does notinclude the scheme (“http”) and host/domain (“www.oblix.com”), andappears before a ‘?’ character in the URL. In the example URL:

http://www.oblix.com/oblix/sales/index.html?user=J.Smith&dept=engg theabsolute path is “/oblix/sales/index.html.”

2. Pattern on name value pairs in the URL: This may be a set ofpatterns. They apply to query data (data appearing after the ‘?’character in the URL when operation is GET, or the POST data ifoperation is POST) and are configured as name (no pattern allowed) plusa pattern or value. For example: variable name pattern user *Smith dept*sales*If multiple name value pairs are specified, they all must match to theincoming resource URL. So the URL:

http://www.oblix.com/oblix/sales/index.html?user=J.Smith&dept=engg willnot match this pattern set. This pattern does not include a notion oforder to these name-value pairs. A URL:

http://www.oblix.com/oblix/sales/index.html?dept=sales&user=J.Smith(with reverse order of “dept” and “user”) will also satisfy thispattern. This is important because it is usually difficult to controlthe order of name value pairs in GET/POST query data.

3. Pattern on the entire query string: This is useful when anadministrator desires to enforce an order on the query string. Forexample, a pattern “user=*Smith*sales” will match query string“user=J.Smith&dept=sales.”

A policy can contain one or more of above types of patterns. If multiplepatterns are specified in one policy, they ALL must match to theincoming resource URL. If not, that policy doesn't apply to the incomingresource URL.

Patterns used for one embodiment of the current invention can use thefollowing special characters:

1. ?: Matches any one character other than ‘/’. For example, “a?b”matches “aab” and “azb” but not “a/b.”

2. *: Matches any sequence of zero or more characters. Does not match‘/’. For example, “a*b” matches “ab,” “azb,” and “azzzzzzb but not“a/b.”

3. [“set”]: Matches one from a set of characters. “set” can be specifiedas a series of literal characters or as a range of characters. A rangeof characters is any two characters (including ‘-’) with a ‘-’ betweenthem. ‘/’ is not a valid character to include in a set. A set ofcharacters will not match ‘/’even if a range which includes ‘/’ isspecified. Examples includes: “[nd] ”matches only “n” or “d”; “[m-x]”matches any character between “m” and “x” inclusive; “[--b]” matches anycharacter between “-” and “b” inclusive (except for “/”); “[abf-n]”matches “a,” “b,” and any character between “f” and “n” inclusive; and“[a-f-n]” matches any character between “a” and “f” inclusive, “-,” or“n.” The second “-” is interpreted literally because the “f” precedingit is already part of a range.

4. {“pattern1,”“pattern2,” . . . }: Matches one from a set of patterns.The patterns inside the braces may themselves include any other specialcharacters except for braces (sets of patterns may not be nested).Examples includes: “a{ab,bc}b” matches “aabb” and “abcb”; “a{x*y,y?x}b”matches “axyb,” “axabayb,” “ayaxb,” etc.

5. “/ . . . /”: Matches any sequence of one or more characters thatstarts and ends with the ‘/’ character. Examples includes: “/ . . ./index.html” matches “/index.html,” “/oblix/index.html,” and“/oblix/sales/index.html,” but not “index.html,” “xyzindex.html,” or“xyz/index.html”; and “/oblix/ . . . /*.html” matches“/oblix/index.html,” “/oblix/sales/order.html,” etc.

6. “\”: Any character preceded by a backslash matches itself. Backslashis used to turn off special treatment of special characters. Examplesinclude “abc\*d” only matches “abc*d”; and “abc\\d” only matches“abc\d.”

To increase the speed of pattern matching, the system tries to do somework up front. When Access Server 34 loads a pattern in its cache, itcreates an object. This object's constructor “compiles” the pattern.This compiling is essentially building a simple state machine from onepattern to other, i.e., it creates a chain of “glob nodes.” Each globnode consists of either one pattern or a node set. For example, considerpattern:

/ . . . /abc*pqr{uv,xy*}.

The chain would look like:

node(“/ . . . /”) ---> node(“abc”) ---> node(“*”) ---> node(“pqr”) --->nodeset(node(“uv”), (node(“xy”) ---> node(“*”)))

Once the chain is constructed, it is used to match a resource URL to thepattern. Each node or node set in this chain takes a pointer to astring, walks it and decides if it matches the pattern held by the node.In doing so, it also moves this pointer further up in the string. Forexample, when the server gets a URL “/1/3/abcdepqrxyz,” the system takesthis string and starts walking the chain. Below is an example ofevaluation at each node/node set and pointer (*p) in the string. Notethat the original string is not modified. To begin with lets assume thatthe pointer points to the beginning of the string: *p->“/1/3/abcdepqrxyz.”:

-   -   Step 1: node(“/ . . . /”) ---> MATCHES ---> advance *p        ->“abcdepqrxyz.”    -   Step 2: node(“abc”) ---> MATCHES ---> advance *p ->“depqrxyz.”    -   Step 3: node(“*”) ---> * matches everything except special        characters (unescaped ‘?, ’‘*, ’‘[, ’‘], ’‘{, ’‘}, ’‘/’), so at        this point, the system tries matching to the next node,        node(“pqr”) like this:        -   a) does *p->“depqrxyz” match node (“pqr”)? NO, advance *p            ->“epqrxyz.”        -   b) does *p->“epqrxyz” match node (“pqr”)? NO, advance *p            ->“pqrxyz.”        -   c) does *p->“pqrxyz” match node (“pqr”)? YES, advance *p            ->“xyz.” If we walked to the end of string and didn't find a            “pqr” (for example in case of URL “/1/3/abcdefgh”) there is            no match.    -   Step 4: nodeset(node(“uv”), (node(“xy”) ---> node(“*”))): A        nodeset will match incoming string (in the example, *p ->“xyz”)        to one of set members. In this case “xyz” does not match “uv,”        but it does match “xy*.” So there is a MATCH and *p ->\‘0.’    -   Step 5: The pointer is at the end of the string. So the match is        successful.        At any point, if the system finds a node that does not match its        string, the system stops processing and concludes that the        string does not match the pattern. For example, a URL “/        1/3/dddddd” will clear step 1 above, but will fail step 2, so        the matching stops after step 2.

Referring to FIG. 26, in step 940, Access Server 34 retrieves the policyinformation from policy domain cache 566. The policy information caninclude one or more of the following: a URL absolute path, a querystring, and zero or more query variables. In step 941, Access Server 34determines whether requested resource matches the policy resource type(see FIG. 21). If the resource type does not match, Access Server 34skips to step 952. However, if the resource type does match, AccessServer 34 proceeds to step 942. In step 942, Access Server 34 determineswhether the operation used to request the resource matches policyoperation type (see FIG. 21). If the operation type does not match,Access Server 34 skips to step 952. If the operation type does match,Access Server 34 proceeds to step 943.

In step 943, the policy URL absolute path, query variables, and querystrings are broken up into various nodes, as described above. In step944, the various nodes are stored. Access Server 34 accesses therequested resource URL in step 946. In step 948, the first node of thepolicy URL is considered by Access Server 34. In step 950, Access Server34 considers whether the considered node matches the resource URL, asdescribed above. If the first node does not match, then the entirepolicy will not match (step 952). If the node does match the resourceURL, or if there are no nodes for the policy, then in step 954 it isdetermined whether there are any more nodes to consider. If more nodesremain to be considered, then in step 956 the next node is consideredand the method loops back to step 950. If there are no more nodes (step954), the query string for the policy is compared to the query string ofthe resource URL in step 958. If the query string for the policy exactlymatches the query string for the resource URL, or if there is no querystring for the policy, then the method continues with step 960. If thequery string for the policy does not match the query string for theresource URL, then the resource URL does not match and is not associatedwith the policy (step 952).

In step 960, it is determined whether there are any query variables (seeFIG. 21) to consider that have not already been considered. If there arequery variables to consider, then the next query variable is accessed instep 964. The accessed query variable is searched for in the resourceURL in step 965. If the query variable is found in the resource URL andthe value for the query variable matches the stored value query variablein for the policy (step 966), then the method continues at step 960;otherwise, Access Server 34 proceeds to step 967. The purpose of steps960, 964, 965, and 966 is to determine whether each of the queryvariables (and associated values) defined for a policy are found, in anyorder, in the resource URL. If all of the query variables are in the URLwith the appropriate values, than there is a match (step 970). In oneembodiment, the query string and the query variables are in the portionof the URL following the question mark.

If in step 966 a match is not found, then it is determined whether amatch may still be possible using POST data. In one embodiment,resources are mapped to policies by matching POST data submitted withresource requests. Thus, different policies can be associated with agiven resource, depending on the contents of the POST data. For example,a user may request a resource during the course of submitting an onlineform containing POST data. Applicable policies can be mapped on thebasis of POST data added to the policy in step 734 of FIG. 21. In step967, Access Server 34 determines whether the policy operation type is anHTTP POST request. If not, then there is no match (step 952). However,if the operation type is an HTTP POST request, then Access Server 34proceeds to step 968 where Access Server 34 requests and receives thePOST data from Web Gate 28. In one embodiment, Web Gate 28 transmits aflag with all POST requests forwarded to Access Server 34. When POSTdata is transmitted with an HTTP POST request, the flag is set. If noPOST data is transmitted, then the flag is not set. In anotherembodiment, retainer 505 is transmitted by Access Server 34 to Web Gate28 when requesting POST data. Retainer 505 is returned by Web Gate 28 toAccess Server 34 with the POST data, thus indicating which policy tocontinue evaluating in step 969. In step 969, Access Server 34 evaluateswhether the POST data received in step 968 matches the POST datarequired by the policy to achieve a match (see FIG. 21). If the POSTdata matches, then the method proceeds to step 970. Otherwise, themethod proceeds to step 952.

FIG. 26A provides a flow chart detailing the steps performed whenmatching a resource with a specific policy using POST data in step 969of FIG. 26. In one embodiment, the steps of FIG. 26A are performed byauthentication module 540. In step 980, Access Server 34 selects thefirst data required for matching the policy under consideration. Then,in step 981, Access Server 34 selects the first item of POST datareceived in step 968 of FIG. 26. Access Server 34 compares the POST datawith the required data (step 982). If a match is found (step 983),Access Server proceeds to step 987. Otherwise, Access Server 34 proceedsto step 984 where it determines whether all of the POST data receivedhas already been compared in step 982. If additional POST data remainsto be compared, Access Server 34 selects the next item of POST datareceived (step 986) and loops back to step 982. If all received POSTdata has already been compared (step 982) and no match was found (step984), then Access Server 34 returns no match (step 985). In step 987,Access Server 34 determines whether additional POST data is required tobe matched in order to match the specific policy under considerationwith the requested resource. If additional data is required, AccessServer 34 selects the next required data (step 988) and loops back tostep 981. If no additional data is required, Access Server 34 returns amatch (step 989).

FIG. 27 provides a block diagram of a retainer data structure (retainer)505 that is passed by Web Gate 28 to Access Server 34 to identify thepolicy domain and policy previously mapped in step 836 of FIG. 23 andstep 932 of FIG. 25, respectively. Retainer 505 is cached in resourcecache 502 in step 850 of FIG. 23. Retainer 505 contains the policydomain ID 992 of the mapped policy domain to be used in authorizationand logging steps, the policy ID 994 for an applicable policy residingin the mapped policy domain, and ID 996 for the applicableauthentication scheme. Thus, by passing retainer 505 rather than thecomplete URL of the requested resource, Web Gate 28 saves Access Server34 from having to repeatedly remap the requested resource to a policydomain and policy during authorization and logging.

FIG. 28 provides a flowchart of a method for authenticating a user forvarious combinations of domains and Web Servers through a singleauthentication performed by the user. As will be apparent to thoseskilled in the art, an Internet domain can reside on a single WebServer, or be distributed across multiple Web Servers. In addition,multiple Internet domains can reside on a single Web Server, or can bedistributed across multiple Web Servers. In accordance with the presentinvention, the method of FIG. 28 allows a user to satisfy theauthentication requirements of a plurality of domains and/or Web Serversby performing a single authentication.

In the simplest case, all of an e-business host company's Web Serverswill be in the same domain (i.e. oblix.com). When a user successfullyauthenticates at one of the Web Servers, the Web Gate running on theauthenticating Web Server causes the Web Server to return an encryptedcookie, indicating a successful authentication. Subsequent requests bythe browser to the domain will pass this cookie (assuming the cookieapplies to the requested URL), proving the user's identity; therefore,further authentications are unnecessary.

In a more complex case, an e-business host company's web presenceincorporates associated web sites whose Web Servers have names inmultiple domains. In such a multiple domain case, each of the associatedportal Web Servers use a Web Gate plug-in configured to redirect userauthentication exchanges to the e-business host's designated web log-inWeb Server. The user is then authenticated at the e-business host's weblog-in server, and an encrypted cookie is issued for the e-businesshost's domain to the user's browser. The user's browser is then isredirected back to the original associated portal's site where the WebGate creates a new cookie for the associated portal's domain and returnsit to the user's browser.

As a result, the user is transparently authenticated in both theoriginal associated portal's domain and the e-business host's domain.The process is transparently performed for each different associatedportal that a user may visit during a session. The present invention'sassociated portal support easily supports single Web Servers havingmultiple DNS names in multiple domains, and/or multiple networkaddresses. In accordance with the present invention, this multipledomain authentication enables “staging” of web sites. For example, a newedition of a web site can be deployed on a separate set of servers, andthen mapped to policy domains protected by the present invention bysimply updating the policy domain's host ID's.

In one embodiment, the steps of FIG. 28 are performed by authenticationevent handler 512 and redirection event handler 504. In step 1020,authentication event handler 512 determines whether single or multipledomains are protected in a given deployment of the present invention. Ifonly a single domain is protected, then the method proceeds to step 1022where an authentication is attempted at the single domain. If the singledomain is distributed across multiple Web Servers, then the domainattribute of the cookie set by the authenticating Web Server in step1022 is set to broadly include all Web Servers in the domain.

If multiple domains are protected, the method proceeds to step 1024where authentication event handler 512 determines whether the multipleprotected domains all reside on a single Web Server. For example, asingle machine intranet.oblix.com may be addressed in multiple ways suchas: sifl.oblix.com, intranet, asterix.oblix.com, or 192.168.1. Inaccordance with the present invention, when multiple domains reside on asingle Web Server, an administrator will designate exactly one of thedomains a “preferred host domain.” If step 1024 indicates that allprotected domains reside on the same Web Server, then authenticationevent handler 512 determines whether the domain of the requestedresource is a preferred host (step 1026). If it is a preferred host,then authentication event handler 512 attempts to authenticate the userat the preferred host domain in step 1030 (further described below withrespect to FIG. 30). Otherwise, redirection event handler 504 redirectsbrowser 12 to the preferred host domain (step 1028) for authentication(step 1030). Referring to step 1024, if the multiple protected domainsreside on multiple Web Servers, then authentication event handler 512proceeds to step 1032.

In one embodiment, a single policy domain and/or policies are createdfor the preferred host domain while no policy domains or policies arecreated for the other domains residing on the same web server. Allresource requests made to any of the multiple protected domains residingon the same web server are redirected to the preferred host domain, thusrequiring the user to authenticate according to the preferred hostdomain's policy domain and/or policies. As a result, afterauthentication at the preferred host domain, the user is transparentlyauthenticated for all other domains residing on the same web server.When subsequent resource requests for resources in domains residing onthe same web server are redirected to the preferred host domain, theprior successful authentication for the host domain can be confirmed bythe existence of a valid authentication cookie for the preferred hostdomain. If such a cookie exists, then the user need not re-authenticatefor the requested resource. In one embodiment, if subsequent resourcerequests made to the preferred host domain (or any of the other domainson the same web server) require a higher level of authentication, or ifa previously valid authentication has expired, the user will be requiredto re-authenticate at the preferred host domain in accordance with themethod of FIG. 28.

FIG. 29 provides a block diagram of a plurality of Web Servers, eachhosting a different domain accessible by browser 1082. In accordancewith the present invention, when multiple domains are protected anddistributed across multiple Web Servers, the administrator will identifyexactly one of the domains a “master domain.” As identified in FIG. 29,Web Server 1070 hosts master domain A.com, while Web Servers 1072 and1074 host domains B.com and C.com, respectfully. An end user's resourcerequest is illustrated in FIG. 29 by path 1084 from browser 1082 to WebServer 1072.

Referring back to FIG. 28, if authentication event handler 512determines that the domain of the requested resource is a master domain(step 1032), then authentication event handler 512 attempts toauthenticate at the master domain (step 1034). Otherwise, redirectionevent handler 504 redirects browser 12 to the master domain (step 1036).The user then authenticates at the master domain (step 1038). Theredirection and authentication of steps 1036 and 1038 are illustrated inFIG. 29 by path 1086. Upon a successful authentication at the masterdomain, the master domain Web Server passes an authentication cookie tothe user's browser (step 1040) and re-directs the user's browser back tothe first domain accessed by the user (step 1042). Also in step 1042,the master domain passes information contained in the master domainauthentication cookie to the first domain in the query data portion ofthe redirection URL. Steps 1040 and 1042 are illustrated by paths 1088and 1090, respectively in FIG. 29. In step 1044, the Web Gate of thefirst domain Web Server extracts the master domain authentication cookieinformation from the redirection URL, thus confirming the user'sauthentication at the master domain and resulting in a successfulauthentication (step 1046). The first domain Web Server (B.com) thensends its own authentication cookie to web browser 1082 (as depicted bypath 1092) in accordance with step 780 of FIG. 22, previously describedabove. Any subsequent authentication by browser 1082 at domain C.com onWeb Server 1074 follows the method of FIG. 28.

FIG. 30 provides a flow chart of the method for authenticating, asperformed in steps 1022, 1030, 1034, and 1038 of FIG. 28. In oneembodiment, the steps of FIG. 30 are performed by authentication eventhandler 512. In step 1120, authentication event handler 512 accessesresource cache 502 to determine what authentication challenge method isto be used for the given resource. Authentication event handler 512 thenaccesses authentication scheme cache 506 in step 1122 to determinewhether the authentication scheme associated with the requested resourcehas been previously cached. If the authentication scheme is found,authentication event handler 512 determines the specific type ofchallenge method in step 1126. If the challenge scheme was not found instep 1122, authentication event handler 512 loads the authenticationrule associated with the requested resource from Directory Server 36 instep 1124 (further described below in FIG. 31), and then proceeds tostep 1126.

In step 1126, authentication event handler 516 discerns whether theauthentication challenge scheme retrieved in step 1122 or 1124 calls forbasic, form, certificate, or no authentication. If the challenge schemeindicates basic authentication, then the method proceeds to step 1128and performs basic authentication. If the challenge scheme indicatesform authentication, then the method proceeds to step 1130 and performsform authentication. If the challenge scheme indicates certificateauthentication, then the method proceeds to step 1132 and performscertificate authentication. If the challenge scheme indicates that noauthentication is required (step 11134), then the user is notchallenged, authentication is not performed (in one embodiment, thesystem skips to step 756 of FIG. 22 and in another embodiment the systemskips to step 774 of FIG. 22).

FIG. 31 provides a flow chart describing the method of loading anauthentication challenge scheme from Directory Server 36 (step 1124 ofFIG. 30). In one embodiment, the steps of FIG. 31 are performed byauthentication event handler 512 and Access Server 34. In step 1160,authentication event handler 512 requests the authentication challengescheme to be read from Access Server 34. If the authentication challengescheme is found in authentication scheme cache 568 (step 1162), thenAccess Server 34 proceeds to step 1168. Otherwise, Access Server 34retrieves the requested authentication challenge scheme from DirectoryServer 36 (step 1164). Upon retrieval, Access Server 34 caches theauthentication challenge scheme in authentication scheme cache 568 (step1166), and proceeds to step 1168. In step 1168, Access Server 34 passesthe retrieved authentication challenge scheme to Web Gate 28. Web Gate28 then caches the authentication challenge scheme in authenticationscheme cache 506 (step 1170).

FIG. 32 provides an exemplar method for performing basic authentication(step 1128 of FIG. 30). In one embodiment, the steps of FIG. 32 areperformed by authentication event handler 512 and authentication module540. In step 1202, authentication event handler 512 instructs browser 12to prompt the user for a user ID and password. In response, the userenters and the user's browser submits the requested user ID and password(step 1204). In step 1206, Web Gate 28 intercepts the user submissionand authentication event handler 512 passes the user ID and password toAccess Server 34, along with retainer 505, thus identifying a policydomain and policy applicable to the requested resource. Access Serverauthentication module 540 then authenticates the user using the user IDand password in step 1208. In step 1210, authentication module 540returns the authentication result, authentication success or failureactions, and any user attributes required by the actions to Web Gate 28.

FIG. 33 provides a flow chart describing an exemplar method used by theAccess Server to authenticate using a user ID and password (step 1208 ofFIG. 32). In one embodiment, the steps of FIG. 33 are performed byauthentication module 540. In optional step 1230, authentication module540 searches user profile cache 576 for a user identity profile entryhaving a user ID attribute matching the user ID received from Web Gate28. User profile cache 576 is a hash table of user identity profileattributes that can be used for authentication, authorization, orauditing. In one embodiment, the user ID attribute would appear in userprofile cache 576 if it was previously used in a successfulauthentication. If a match is found (optional step 1232), thenauthentication module 540 proceeds to step 1234. If no match is found,then authentication module 540 proceeds to step 1236.

In another embodiment, steps 1230 and 1232 of FIG. 33 are not performed.In such an embodiment, the method of FIG. 33 begins with step 1236 whereit searches user identity profiles 102 in Directory Server 36 (not userprofile cache 576) for a user identity profile having a user IDattribute matching the user ID received from Web Gate 28. If no matchinguser identity profile attribute is found in Directory Server 36 (step1238), then the method proceeds to step 1241. If a matching useridentity profile attribute is found in Directory Server 36 (step 1238),then authentication module 540 binds to the directory using thedistinguished name from the matching user identity profile entry and thepassword received from Web Gate 28 (step 1234). If the bind isunsuccessful (step 1240), then authentication module 540 proceeds tostep 1241 where it determines whether an entry for the current user isfound in user profile cache 576. If so, authentication module 540proceeds to step 1243. Otherwise, authentication module 540 retrievesall profile attributes of the current user appearing in user attributelist 114 and caches them in user profile cache 576 (step 1242). In step1243, authentication module 540 returns an unsuccessful authenticationresult.

If the bind is successful (step 1240), then authentication module 540accesses revoked user list 582 to determine whether the user ID receivedfrom Web Gate appears on revoked user list 582. If the user ID is on therevoked user list (step 1244), authentication module 540 proceeds tostep 1241. If the user ID is not on the revoked user list, thenauthentication module 540 determines whether an entry for the user isfound in user profile cache 576 (step 1250). If not, authenticationmodule 540 retrieves all profile attributes of the current userappearing in list 114 and caches them in user profile cache 576 (step1254). If an entry was found, the method skips to step 1260. In step1260, the method returns a successful authentication result.

FIG. 34 provides a flow chart describing a method for performing formauthentication (step 1130 of FIG. 30). In one embodiment, the steps ofFIG. 34 are performed by authentication event handler 512, redirectionevent handler 504, browser 12, and authentication module 540. In step1308, authentication event handler 512 sets a “form login” cookie onbrowser 12. The cookie includes the URL of the requested resource.Authentication event handler 512 then redirects browser 12 to anauthentication form URL (step 1310). In step 1312, Web Gate 28 allowsthe authentication form referenced by the authentication form URL topass to browser 12. The user then fills out the authentication form(step 1314) and transmits (e.g. post data) the information from theauthentication form (step 1316), passing the form login cookiepreviously set in step 1308. Authentication event handler 512 thenextracts the URL of the requested resource from the form login cookie(step 1318), and passes the user ID and password filled out by the userin the authentication form (submitted as POST data) to Access Server 34(step 1320).

In step 1322, authentication module 540 authenticates the user for therequested resource using the user's id and password received from WebGate 28, performing the steps of FIG. 33 previously described above. Instep 1324, authentication module 540 returns the authentication result,authentication actions, and user attributes to Web Gate 28.Authentication event handler 512 then sets the form login cookie(previously set in step 1308) to indicate that the authenticationprocess is completed (step 1326).

FIG. 35 is a flow chart describing a method for performing certificateauthentication (step 1132 of FIG. 30). In one embodiment of the presentinvention, client certificate authentication is performed using WebServers employing the Netscape Enterprise Server plug-in interface(NSAPI). In another embodiment, client certificate authentication isperformed for Web Servers employing the Microsoft Internet InformationServer plug-in interface (ISAPI). In yet another embodiment, clientcertificate authentication is performed on a plurality of Web Servers,with a first subset of the Web Servers employing NSAPI and a secondsubset employing ISAPI. Other Web Servers can also be used.

In one embodiment, the steps of FIG. 35 are performed by authenticationevent handler 512, redirection event handler 504, browser 12, andauthentication module 540. In step 1348, authentication event handler512 requests Web Server 18 to perform SSL client certificateauthentication on browser 12. In one embodiment of the present inventionperforming client certificate authentication on ISAPI Web Servers,authentication event handler 512 redirects browser 12 to a special caseURL (i.e. cert_authn.dll) that is configured to accept certificates. Insuch an embodiment, this redirection occurs within step 1348.

In step 1350, Web Server 18, on behalf of Web Gate 28, sends an SSLclient certificate request along with trusted certificate authorities(CA's) and challenge data to browser 12. Browser 12 then displays aselection box with client certificates from trusted CA's, allowing auser of browser 12 to select a certificate (step 1352). Browser 12 thenreturns the selected certificate with challenge data signed by a privatekey to Web Server 18 (step 1356). Web Server 18 then verifies that thechallenge data was properly signed by the selected certificate (step1360) and passes a valid certificate to Web Gate 28 (step 1362), whichpasses the certificate to Access Server 34 (step 1363). In step 1364,authentication module 540 of Access Server 34 then decodes thecertificate and maps the certificate subject to a valid distinguishedname (further described in FIG. 36). In step 1366, authentication module540 returns the authentication result, authentication actions, and userattributes to Web Gate 28.

FIG. 36 provides a flow chart describing a method for authenticatingusing a valid certificate (step 1364 of FIG. 35). In one embodiment, thesteps of FIG. 36 are performed by authentication module 540. In optionalstep 1390, authentication module 540 decodes one or more fields of thecertificate passed by Web Gate 28 in step 1362 of FIG. 35. In oneembodiment, the user's e-mail address is decoded. In step 1392,authentication module 540 searches user profile cache 576 for a useridentity profile entry having one or more attributes matching thedecoded field(s). In one embodiment, the user attribute would appear inuser profile cache 576 if it was previously used in a successfulauthentication. If a match is found (optional step 1394), thenauthentication module 540 proceeds to step 1406. If no match is found,then authentication module 540 proceeds to step 1396.

In another embodiment, steps 1390 and 1392 of FIG. 36 are not performed.In such an embodiment, the method of FIG. 36 begins with step 1396 whereit searches user identity profiles 102 in Directory Server 36 for a useridentity profile having one or more attributes matching the decodedfield(s). If no matching user identity profile attribute is found inDirectory Server 36 (step 1398), then the method proceeds to step 1402where it determines whether an entry for the current user is found inuser profile cache 576. If so, authentication module 540 proceeds tostep 1405. Otherwise, authentication module 540 retrieves all profileattributes of the current user appearing in user attribute list 114 andcaches them in user profile cache 576 (step 1404). In step 1405,authentication module 540 returns an unsuccessful authentication result.If a matching user identity profile is found in step 1398, the methodproceeds to step 1406.

In step 1406, authentication module 540 accesses revoked user list 582to determine whether the user identity profile having the matching userattribute appears on revoked user list 582. If so, authentication module540 proceeds to step 1402. Otherwise, authentication module 540continues on to step 1410 and determines whether an entry for thecurrent user is found in user profile cache 576. If not, authenticationmodule 540 retrieves all profile attributes of the current userappearing in list 114 and caches them in user profile cache 576 (step1416). If an entry was found, the method skips to step 1422. In step1422, the method returns a successful authentication result.

FIG. 37 provides a block diagram of an authentication cookie 1450 passedby Web Gate 28 to browser 12 in step 780 of FIG. 22. Cookie 1450 isencrypted with a symmetric cipher so that cookies from all instances ofWeb Gate 28 in a given deployment of the present invention may beencrypted using the same key. This key (shared secret 110) is stored onDirectory Server 36 and distributed to each of the Web Gates 28 byAccess Server 34. Shared secret 110 can change as often as desired by anadministrator. In one embodiment of the present invention, cookie 1450is encrypted using RC4 encryption with a 2048 bit key. As previouslydescribed, in one embodiment, previously valid keys are grandfatheredsuch that both the current key and the immediately prior key will bothwork to de-crypt encrypted cookie 1450. The present invention features aone-button key re-generation function. This function is easilyscriptable.

In one embodiment, the information stored by cookie 1450 includes theauthentication level 1452 of the authentication scheme used to createthe cookie, the user ID 1454 of the authenticated user, the IP address1456 of the authenticated user, and session start time 1458 identifyingthe time at which cookie 1450 was created. If the time elapsed since thesession start time 1458 exceeds a maximum session time, the cookie willbecome invalid. Idle start time 1460 is also stored, which identifiesthe time when the previous HTTP request for a protected resource wasmade in which cookie 1450 was passed. If the time elapsed since the idlestart time 1460 exceeds a maximum idle time, the cookie will becomeinvalid. Both of these time limits force users to re-authenticate ifthey have left a session unattended for longer than the maximum sessionor idle times. Cookie 1450 also stores a secured hash 1462 ofinformation 1452, 1454, 1456, 1458, and 1460. In one embodiment of thepresent invention, secured hash 1462 is created using an MD5 hashingalgorithm. Most Internet browsers cache a user's supplied authenticationinformation during basic and certificate authentication challengemethods, and then transparently re-send the information upon receivingan authentication challenge from a Web Server. In one embodiment, anadministrator can enable a form authentication challenge methodrequiring end users to re-authenticate upon expiration of the maximumsession or maximum idle time limits.

FIG. 38 provides a flow chart describing a method for attempting toauthorize a user (step 756 of FIG. 22). In one embodiment, the method ofFIG. 38 is performed by authorization event handler 516 andauthorization module 542. In step 1490, authorization event handler 516of Web Gate 28 passes authorization information to Access Server 34. Instep 1494, authorization module 542 determines whether one or moreauthorization rules associated with the requested resource are found inauthorization rule cache 572. If one or more rules are found,authorization module 542 proceeds to step 1496. Otherwise, authorizationmodule 542 retrieves any authorization rules associated with therequested resource from Directory Server 36 in step 1498. In oneembodiment, authorization success and failure actions are retrieved withthe authorization rules. After retrieving the authorization rules,authorization module 542 proceeds to step 1496 and reads the firstauthorization rule associated with the requested resource fromauthorization rule cache 572. In one embodiment, multiple authorizationrules are evaluated in an order determined by the priority set in step646 of FIG. 17. In another embodiment, second level authorization rulesare evaluated prior to first level authorization rules. Authorizationmodule 542 applies the authorization rule (step 1500) to theauthorization information previously passed in step 1490.

If the authorization rule is satisfied in step 1502, authorizationmodule 542 determines whether an entry for the user is found in userprofile cache 576 (step 1504). If so, authorization module 542 proceedsto step 1508. If not, authorization module 542 retrieves all profileattributes of the current user appearing in user attribute list 114(step 1507), and communicates the authorization success actions andattributes to Web Gate 28 (step 1508).

If the authorization rule is not satisfied (step 1502), thenauthorization module 542 determines whether more authorization rulesremain to be evaluated (step 1509). If more rules remain, the next ruleis read (step 1496) and evaluated (step 1500). If no more rules remain,authorization module 542 determines whether an entry for the user isfound in user profile cache 576 (step 1510). If so, authorization module542 proceeds to step 1512. If not, authorization module 542 retrievesall profile attributes of the current user appearing in user attributelist 114 (step 1511), and communicates the authorization success actionsand attributes to Web Gate 28 (step 1512).

FIG. 39 details the steps performed when passing authorizationinformation to Access Server 34 in step 1490 of FIG. 38. In oneembodiment, the steps of FIG. 39 are performed by authorization eventhandler 516. In one embodiment, authorization can be performed usingPOST data. In another embodiment, POST data is not used forauthorization. If POST data is enabled to be used for authorization,then the method of FIG. 39 begins with optional step 1530. Otherwise,the method begins at step 1534. If the resource request issued bybrowser 12 in step 750 of FIG. 22 employs a POST request method and POSTdata is enabled to be used for authorization (step 1530), authorizationevent handler 516 passes the POST data and retainer 505 to Access Server34 (step 1536). If the resource request does not employ a POST requestmethod or POST data is not enabled to be used for authorization (step1530), then authorization event handler 516 passes retainer 505, therequest method, the user's distinguished name, the user's IP address,and the time of the request to Access Server 34 in step 1534.

FIG. 40 illustrates the format of an HTTP request. As illustrated inFIG. 40, an HTTP request 1550 comprises request line 1552, zero or moreheaders 1554, blank line 1556, and body 1558 (used only for POSTrequests). The HTTP protocol supports various types of requests. The GETrequest returns whatever information is identified by the request-URIportion of request line 1552. The HEAD request is similar to the GETrequest, but only a server's header information is returned. The actualcontents of the specified document is not returned. This request isoften used to test hypertext links for validity, accessibility, andrecent modifications. The POST request is used for POSTing electronicmail, news, or sending forms that are filled in by an interactive user.A POST is the only type of request that sends a body. A validcontent-linked header field is required in POST requests to specify thelength of body 1558. Post data can include zero or more data elementsseparated by “&” as depicted by line 1562. Each data element is of theform variable name =value.

HTTP request 1550 can contain a variable number of header fields 1560. Ablank line 1556 separates header fields 1554 from body 1558. A headerfield comprises a field name, a string and the field value, as depictedin box 1560. In one embodiment, the field value is an LDAP attribute.Field names are case insensitive. Headers can be divided in threecategories: those that apply to requests, those that apply to responses,and those that describe body 1558. Certain headers apply to bothrequests and responses. Headers that describe the body can appear in aPOST request or in any response.

FIG. 41 provides a flow chart describing a method for loading anauthorization rule from the Directory Server (step 1498 of FIG. 38). Inone embodiment, the steps of FIG. 41 are performed by authorizationmodule 542. In step 1580, Access Server 34 loads the defaultauthorization rule for the policy domain mapped in step 836 of FIG. 23from Directory Server 36 into authorization rule cache 572. AccessServer 34 then selects a first rule in array 565 (step 1582) anddetermines whether the selected rule is a second level (specific) ruleof a policy associated with the requested resource (step 1584), bycalling the method of FIG. 26 previously described above. If yes, thenAccess Server 34 proceeds to step 1592. Otherwise, Access Server 34determines whether all rules in array 565 have been evaluated (step1586). If not, then Access Server 34 selects the next rule in array 565(step 1588), and returns to step 1584. Once all rules in array 565 havebeen considered (step 1586), Access Server 34 proceeds to step 1594 andloops back to step 1586. If a second level authorization rule (a ruledefined in a policy) was found for the requested resource in step 1584,then authorization module 540 caches the second level authorization rulein authorization rule cache 570 (step 1592) and the method is done (step1594). If a second level policy authorization rule was not found, thenthe default authorization rule previously loaded in step 1580 remains inauthorization rule cache 572, and the method is done (step 1594).

FIG. 42 provides a flow chart describing the method of applying anauthorization rule (step 1500 of FIG. 38). In one embodiment, the stepsof FIG. 42 are performed by authorization module 542. In one embodiment,authorization can be performed using POST data. In another embodiment,POST data is not used for authorization. If POST data is to be used forauthorization, then the method of FIG. 42 begins with optional step1620. Otherwise, the method begins at step 1624. In optional step 1620,if the resource request employs a POST request method, thenauthorization module 542 proceeds to optional step 1622 where it appliesthe authorization rule to the POST data passed in step 1536 of FIG. 39.If the resource request does not employ a POST request method (or ifPOST data is not enabled to be used for authorization), thenauthorization module 542 proceeds to step 1624. If specific users aredefined (by distinguished name) in the authorization rule, authorizationmodule 542 evaluates whether the distinguished name of the authenticateduser matches the user's distinguished name called for by theauthorization rule (step 1626). If specific groups are defined in theauthorization rule (step 1628), authorization module 542 evaluateswhether the group name of the authenticated user matches the group namecalled for by the authorization rule (step 1630). In one embodiment, theuser's group membership is cached in user policy cache 578. If specificroles are defined in the authorization rule (step 1632), authorizationmodule 542 evaluates whether the role of the authenticated user matchesthe role called for by the authorization rule (step 1634). If specificLDAP rules are defined in the authorization rule (step 1640),authorization module 542 evaluates whether the LDAP rule matches theLDAP rule called for by the authorization rule (step 1642). In oneembodiment, the result of the LDAP rule evaluation in step 1642 iscached in user policy cache 578. If specific user IP addresses aredefined in the authorization rule (step 1644), authorization module 542evaluates whether the IP address of the authenticated user matches theIP address called for by the authorization rule (step 1646). If asuccessful match is found at any point (steps 1627, 1631, 1635, 1643,and 1647), the authorization is successful (step 1650). In oneembodiment, successful matches of groups and LDAP rules are stored inuser policy cache 578 in steps 1631 and 1643. In another embodiment,multiple matches must be found before an authorization success is found.If no matches are found, authorization is unsuccessful (step 1652).

FIG. 43 provides a flow chart detailing the steps performed whenapplying an authorization rule to POST data in optional step 1622 ofFIG. 42. In one embodiment, the steps of FIG. 43 are performed byauthorization module 542. In step 1670, Access Server 34 selects thefirst item of POST data received in optional step 1536 of FIG. 39. Ifthe selected POST data is of a type that is called for by theauthorization rule being evaluated (step 1672), then Access Server 34evaluates whether the selected POST data matches data required by theauthorization rule (step 1674) and determines whether a successful matchhas been found (step 1675). For example, if an authorization rule callsfor a user's distinguished name, then a distinguished name contained inthe POST data will be compared with the distinguished name expected bythe authorization rule. If the selected POST data equals the expecteddistinguished name, then a successful match will be found for theexample above. If a match is found (step 1675), Access Server proceedsto step 1682 where it returns a successful authorization. Otherwise,Access Server proceeds to step 1676. If, in step 1672, it is determinedthat the type of POST data was not called for, then Access Server 34proceeds directly to step 1676.

In step 1676, Access Server 34 determines whether all of the POST datareceived in step 1536 has been considered by step 1672. If additionalPOST data remains to be considered (step 1676), Access Server 34 selectsthe next available item of POST data (step 1678) and loops back to step1672. If no POST data remains to be considered and a match still has notbeen found (step 1676), access Server 34 proceeds to step 1684 andreturns an authorization failure.

FIG. 44 is a flow chart describing the process of performingauthentication success actions (step 776 of FIG. 22). In step 1700, WebGate 28 determines whether there is a redirect URL. As described above,when setting up a policy domain or a policy, an administrator can set upa redirect URL for authentication success/failure events as well asauthorization success/failure events. An administrator can also set upvarious variables to add to an HTTP request based on these events. If,in step 1700, it is determined that a redirect URL exists for anauthentication success event, then in step 1702 it is determined whetherthere are any HTTP variables to add to the HTTP request. If it wasdetermined in step 1700 that there was not a redirect URL, then in step1704, it is determined whether there are any HTTP variables to add tothe request. If, in step 1704, it is determined that there are HTTPvariables to add to the request in response to the authenticationsuccess event, then in step 1706, the header variables are added. If, instep 1704, it is determined that there are no HTTP variables to add tothe request, then no action is performed (step 1708). If, in step 1702,it is determined that there are no HTTP variables to add to the request,then in step 1710 the redirect URL is added to the HTTP request andbrowser 12 is redirected using the HTTP request in step 1712. If in step1702 it is determined that there are HTTP variables to add to therequest, then in step 1714 the redirect URL is added to the HTTP requestand, in step 1716, the header variables are added to the HTTP request.In step 1718, the browser is redirected using the newly constructed HTTPrequest.

When a Web Server receives an HTTP request, the Web Server stores thecontents of the HTTP request in a data structure on the Web Server. AWeb Gate can edit that data structure using an API for the Web Server.In one embodiment, the downstream application that will be using theheader variables is on, accessed using or associated with the same WebServer storing the HTTP request. In that case, the header variable areadded (e.g. in step 1706) by storing the header variables in the datastructure on the Web Server. Subsequently, the Web Server will providethe header variables to the downstream application.

FIG. 45 is a flow chart describing the steps of performingauthentication and authorization failure actions (see steps 766 and 798of FIG. 22, respectively). In step 1738, Web Gate determines whetherthere is a redirect URL for the authorization failure or authenticationfailure, whichever event is being considered. If there is no redirectURL, then in step 1740, it is determined whether there are any HTTPvariables for the authorization failure or authentication failure. Ifthere are no HTTP variables, then in step 1742, a default failure URL isadded to a new HTTP request. The default failure URL is a URL thatpoints to a web page that notifies a user that access is denied to theresource. In other embodiments, other pages can be used as defaultfailure pages. In step 1744, the user's browser 12 is redirected usingthe HTTP request that includes the default failure URL. If, in step1740, it is determined that there are HTTP variables to add to the HTTPrequest for the particular authentication failure or authorizationfailure event, then in step 1746, those variables are added as headervariables to the HTTP request. In step 1748, the default failure URL isadded to the HTTP request. The user's browser is redirected using theHTTP request in step 1750.

If, in step 1738, it is determined that there is a redirect URL for theparticular authentication failure or authorization failure event, thenit is determined whether there are any HTTP variables for thisparticular action in step 1752. If not, the redirect URL is added to theHTTP request in step 1754 and the browser is redirected using the HTTPrequest in step 1756. If, in step 1752 it is determined that there areHTTP variables to add to the request, then in step 1758, the redirectURL is added to the HTTP request. In step 1760, the header variables areadded to the HTTP request. The user's browser is then redirected usingthe HTTP request in step 1762.

FIG. 46 is a flow chart describing the process of performingauthorization success actions (step 794 of FIG. 22). In step 1782, it isdetermined whether there is a redirect URL for the authorization successaction. If there is no redirect URL, then in step 1784 it is determinedwhether there are any HTTP header variables to add. If so, the headervariables are added in step 1786. For example, the header variables canbe added to the data structure for the request that is stored on the WebServer. Subsequently, the Web Server will provide the header variablesto the downstream application(s). If, in step 1784 it is determined thatthere are no HTTP variables to add to the request, then no action istaken.

If it is determined in step 1782 that there is a redirect URL, then instep 1796, it is determined whether there are any HTTP variables to addto the request. If there are not any HTTP variables to add to therequest, then the redirect URL is added to the HTTP request in step1798. In step 1800, the user's browser is redirected using the HTTPrequest with the redirect URL. If it is determined that there are HTTPvariables to add to the request in step 1796, then the redirect URL isadded to the HTTP request in step 1802. In step 1804, the HTTP variablesare added as header variables to the HTTP request. In step 1806, theuser's browser is redirected using the HTTP request.

FIG. 47 is a flow chart describing the process of how a downstreamapplication or other resource uses header variables provided by thesystem of FIG. 1. Upon authorization success, authorization failure,authentication success or authentication failure, various data can beadded as header variables. In step 1830, the resource receives therequest. In one embodiment, the resource receives request informationfrom a Web Server. In another embodiment, the resource receives aredirected HTTP request. In step 1832, the resource determines whetherthere are any header variables to consider. If there are no headervariables, then in step 1834, the resource responds to the request.Responding to the request can include providing a web page, access to asoftware process or anything else appropriate for the particularresource. If, in step 1832, it is determined that there are headervariables, then in step 1836 the resource searches for a particularvariable name. In order to use header variables, the resource must bepreprogrammed to know what header variables to expect and how to usethem. Thus, the resource will have a list of variable names it seeks. Instep 1836, the resource looks for one of the listed variable names inthe set of header variables. Once found, the resource reads the stringfor the found variable in step 1838. In step 1840, the resource readsthe variable value (e.g. LDAP attribute). When HTTP variables are set upin actions, a variable name, a string for the variable and data for thevariable are provided. In step 1842, it is determined whether anyvariables to operate on. If so, the method of FIG. 47 loops back to step1836. If there are no more variables to operate, then in step 1844 theresource acts on the variables by taking the information from thevariables and using them in the manner appropriate for the particularresource. In step 1846, the resource responds to the request asappropriate for that particular resource.

One example for using the process of FIG. 47 is to provide an automatedlogin for a downstream application. For example, upon authentication orauthorization successes, login information for a particular user and aparticular application can be added to the HTTP request as headervariables. The downstream application can be programmed to search theheader variables for the login and password information andautomatically attempt to authorize the user. In another example, useridentity profile information is passed to a downstream applicationwithout the user accessing the application directly. This user identityprofile information would be stored in header variables and provided tothe resource being accessed. Thus, the resource being accessed can befully customized for the user accessing the resource. For example, theresource can address the user by name and title and access preferencesfor that user. There are an unlimited number of resources that can beaccessed by a user and, thus, unlimited ways to use the informationcontained in header variables.

As discussed above, the Access System monitors and logs various events,including authorization and authentication failure/success events. Inother embodiments, other events can be monitored and logged. When anevent being monitored occurs, an entry is added to an appropriate auditlog. For purposes of the present invention, the terms log and log entryare used broadly because no special format is necessary for the presentinvention. A log can include any reasonable and organized system forstoring information.

FIG. 48 provides a flow chart detailing the steps performed for loggingauthentication and/or authorization events (see steps 764, 774, 792, and796 of FIG. 22). In one embodiment, the steps of FIG. 48 are performedby Web Gate 28 and auditing module 544. The log process is configurablebecause the audit rule associated with a requested resource can specifyany combination of information to be logged in audit logs 546 inresponse to a detected type of event selected to be audited. Forexample, in one embodiment of the present invention, an audit ruleassociated with a requested resource can specify that all or a subset ofthe attributes of the identity profile for the user making the accessrequest should be logged in one of audit logs 546 for the specificevent. In another embodiment, the time of the authentication and anidentification authorization event is logged in one or more of auditlogs 546. An identification of the resource, the rule evaluated, thetype of event, the IP (or other) address of the requesting machine, userID, an identification of the operation being performed (e.g. GET, etc.)an identification of the Web Gate and/or access server that processedthe request, user password and any other suitable information can alsobe logged.

Storing identity profile information, as well as the other informationlisted above, allows the system to provide data for load balancing,various business reports, and reports about how the system is beingused. For example, knowledge of which resources are being accessed, whenresources are being used and who is accessing the resources can allow anadministrator to perform load balancing on the system. Reportsidentifying which content is being accessed the most can help a businessallocate resources. Information about how various entities use thesystem can provide behavioral data to the host. Various other businessreports and monitoring can also be useful.

The process of FIG. 48 is commenced by the detection of an access systemevent. In the embodiment of FIG. 22, both the attempt to authenticate(steps 760 & 762) and the attempt to authorize (steps 756 & 790) can bethought of as the detection of an access system event. Thus, the accesssystem events of the embodiment of FIG. 22 includes authorizationsuccess, authorization failure, authentication success andauthentication failure. Other access system events can also be monitoredfor use with the present invention. In other embodiment, detecting anaccess system event can utilize different means than explicitlydescribed in FIG. 22, as long as the system has a means for knowing thatan event occurred. Alternatively, an access system event can be detectedusing specific monitors or sensors.

In step 1870 of FIG. 48, Web Gate 28 reads audit mask 503 from resourcecache 502 in response to an authentication or authorization result. Ifaudit mask 503 indicates that the event is not audited (step 1872), thenthe method is done (step 1874). If the event is to be audited (step1872), then Web Gate 28 passes retainer 505 to auditing module 544, thusidentifying the applicable policy domain and/or policy for auditing. Instep 1878, auditing module 544 reads the audit rule associated with therequested resource from audit rule cache 574. In one embodiment, theaudit rule read in step 1878 will be a first level (default) audit rule,a second level (specific) audit rule, or a master audit rule applicableto all resources when neither a first or second level audit rule isfound. In step 1880, auditing module 544 logs information specified bythe found audit rule into one or more audit logs 546. In one embodimentof the present invention, Access Server 34 informs auditing module 544of authentication and authorization events to be logged, thus, allowingauditing module 544 to perform steps 1878 and 1880 directly in responseto an authentication or authorization result, rather than waiting to beprompted by Web Gate 28.

FIG. 49 provides a flow chart of a method for loading audit rules (seestep 846 of FIG. 23). In step 1900, Access Server 34 loads the defaultaudit rule for the policy domain mapped in step 836 of FIG. 23 fromDirectory Server 36 into audit rule cache 574. Access Server 34 thenselects a rule in array 565 (step 1902) and determines whether theselected rule is a specific audit rule for a policy associated with therequested resource, by using the method of FIG. 26 previously describedabove (step 1904). If the resource is part of the policy, then AccessServer 34 proceeds to step 1912. Otherwise, Access Server 34 determineswhether all rules in array 565 have been considered (step 1906). If not,then Access Server 34 selects the next rule in array 565 (step 1908),and returns to step 1904. Once all rules in array 565 have beenconsidered (step 1906), Access Server 34 proceeds to step 1912. If asecond level authentication rule was found for the requested resource instep 1904, then authentication module 540 caches the second level auditrule in audit rule cache 574 (step 1912) and proceeds to step 1914. Instep 1914, Access Server 34 prepares audit mask 503, identifying theauthentication and authorization events to be logged (audited) byauditing module 544 in accordance with the second level audit rule. If asecond level audit rule was not found (step 1910), then the first levelaudit rule previously loaded in step 1484 remains in audit rule cache574, and Access Server 34 prepares audit mask 503 using the first levelaudit rule. Thus, when the method of FIG. 49 is done, only one auditrule for the requested resource will remain in audit rule cache 574.

FIG. 50 depicts one embodiment of components used to detect attemptedintrusions. The attempted intrusions can be inadvertent or malicious.The goal is to detect attempted intrusions of the access system, whichincludes the protected resources. FIG. 50 shows audit logs 546 which canbe one or more logs for logging various events. For example, there couldbe one log for logging authentication failure events, one log forlogging authorization failure events, etc. Alternatively, there could beone log for logging multiple types of events. In one embodiment, foreach log, or each type of event, an audit log sensor 548 monitors thetype of event occurring. For example, in one embodiment there is anauthentication failure sensor and an authorization failure sensor. Ifother events are monitored, there can be a sensor for each of the otherevents. When an authorization failure event occurs and a log entry isadded to audit log 546 for the event, the authorization failure sensorwill make a copy of the log entry and send it to database server 1934.Each of the audit log sensors 548 will send copies of log entries theydetect to database server 1934. In one embodiment, database server 1934includes an SQL database for storing all of the received log entries.Periodically, database server 1934 sends a set of log entries tosecurity server 1936. In one embodiment, database server 1934 is storedwithin the local system of FIG. 1 and security server 1936 is locatedoffsite. In one embodiment, database server 1934 is not provided and thevarious log sensors send their log entries directly to security server1936. As discussed above, the audit log entries are fully configurable.The log entries sent by the sensors can be exact duplicates of the logentries in the audit logs or they can be reformatted versions orversions that store only a subset of the original information.

FIG. 51 provides a flow chart describing the operation of the componentsdepicted in FIG. 50. In step 1950, an event is logged. The system isfully configurable to allow the sensors to monitor all or a subset ofevents being logged. The events being monitored by sensors 548 aredenoted as registered events. For example, in one embodiment, the systemlogs all authentication failure, authentication success, authorizationfailure and authorization success events, while sensors 548 monitor onlyauthentication failure and authorization failure events. In step 1952,it is determined whether the logged event is a registered event. If not,the method of FIG. 51 is done (step 1964). If it is a registered event,then in step 1954 the sensor accesses instructions for the event type.For each event type being monitored by a sensor, the system isconfigurable to perform any action specified by the administrator. Forexample, in one embodiment, an action will be to send the log entry to adatabase server. In another embodiment the action will also includeadding information to the log entry such as information from a useridentity profile, login information, time, date, etc. In step 1956,sensor 548 accesses the log entry and performs instructions for theevent type to the log entry in step 1958. As discussed above, oneexemplar instruction requests that the sensor sends the log entry toeither database server 1934 or security server 1936. If the sensor isinstructed to send the log entry to database server 1934, then databaseserver 1934 receives and stores the log entry in step 1960. In step1962, database server 1934 will periodically send all or a subset of thelog entries to security server 1936.

FIG. 52 is a flow chart describing the operation of security server1936. In step 1980, security server 1936 receives a log entry. Step 1980could include receiving a particular log entry directly from a sensor548 or receiving a set of log entries from database server 1934. In step1982, the log entries are stored at security server 1936. In step 1984,a rules engine is run on a set of stored log entries. The log entriesused in step 1984 could include the newest set of log entries and,optionally, previous log entries going back historically as needed bythe rules engine. The rules engine can look for any particular patternof events. In one embodiment, the steps of FIGS. 51 and 52 are used todetect one or more attempts of intrusion of the system. For intrusiondetection, the rules engine looks for patterns over time of an entityattempting to wrongfully access resources in the system of FIG. 1. Insuch a case, various patterns can be detected. For example, the rulesengine may look for three authorization failures for the same entity orthree authentication failures with the same login name or password.Security server 1936 correlates events over time to identify persons oractions that constitute security breaches or attempted securitybreaches.

FIG. 53 provides a flow chart detailing the steps performed by AccessManager 40 for flushing and synchronizing caches of Web Gate 28 andAccess Server 34 in accordance with the present invention. If a changeis made (by an administrator, user, or otherwise) to a policy domain ora policy stored on Directory Server 36, any affected first level orsecond level rules cached in the respective caches of Web Gate 28 andAccess Server 34 will become stale data. Similarly, if a change is madeto user identity profiles 102 or revoked user list 108 on DirectoryServer 36, previously cached versions of the changed data will becomestale. Accordingly, the respective caches of Web Gate 28 and AccessServer 34 must be flushed to prevent Web Gate 28, Access Server 34, UserManager 38, Access Manager 40, or System Console 42 from using the staledata.

In step 2010, Access Manager 40 detects a change to data stored onDirectory Server 26. In step 2012, Access Manager 40 reads the previousGlobal Sequence Number (GSN) 112 stored on directory server 36. In step2014, Access Manager 40 assigns a current GSN to the change detected instep 2010. In one embodiment of the present invention, the current GSNis the next sequential number after the previous GSN 112. In step 2016,Access Manager 40 stores the current GSN on Directory Server 36,replacing the previous GSN 112. In step 2018, Access Manager 40generates a synchronization (sync) record to facilitate cache flushing.In step 2020, Access Manager 40 passes a cache flush request and thenewly generated synchronization record to each Access Server 34.

FIG. 54 provides a block diagram of a synchronization record inaccordance with the present invention. Synchronization record 2040includes the current GSN 2042 assigned to the change detected in step2010 of FIG. 53. Synchronization record 2040 also includes IDs 2044,which identify the data affected by the detected change, such as thepolicy domain, first level rules, policy, second level rules, etc.Synchronization record 2040 also indicates what type of change 2046 wasdetected (e.g. whether it be an addition, modification, or deletion).Time 2048 is also stored, indicating the time at which the change wasdetected in step 2010.

FIG. 55 provides a flow chart detailing steps performed by Access Server34 in response to receiving a synchronization record 2040 from AccessManager 40. In step 2060, Access Server 34 receives a synchronizationrecord and flush request. Access Server 34 updates its stored GSN byreplacing the stored GSN with the synchronization record GSN (step2066). In step 2068, Access Server 34 then flushes the cachedinformation identified by elements 2044, 2046, and 2048 ofsynchronization record 2040. Access Server 34 then storessynchronization record 2040 on Access Server 34 (step 2070).

FIG. 56 provides a flow chart detailing the steps performed by Web Gate28 for flushing and synchronizing its caches in accordance with thepresent invention. In step 2100, Web Gate 28 issues a request to AccessServer 34. Upon serving the request, Access Server 34 returns the valueof its stored GSN 554 (step 2102) to Web Gate 28. Web Gate 28 comparesthe GSN 544 returned in step 2102 with GSN 510 stored by Web Gate 28(step 2104). Web Gate 28 requests all synchronization records 550 storedon Access Server 34 having GSN's greater than GSN 510 stored on Web Gate28 or appearing in sync record table 518. Web Gate 28 flushes datahaving ID's 2044 (specified in synchronization record 2040 received fromAccess Server 34) from its caches (step 2110). In step 2112, Web Gate 28updates its GSN 510 to equal GSN 554 stored on Access Server 34 (step2112). In one embodiment, Web Gate 28 maintains a sync record table 518that identifies all sync records that have not yet been processed by WebGate 28. For example, a sync record will remain unprocessed if itstransmission to Web Gate 28 from Access Server 34 is delayed. In step2114, Web Gate 28 updates table 518 by removing entries forsynchronization records processed in step 2110.

FIG. 57 provides a flow chart describing the process of testing accessto resources using the system of FIG. 1. Access Manager 40 includes anAccess Tester process. The Access Tester allows an administrator, or anyother authorized user, to determine who or what entities may access aresource under the current access criteria, whether a particularindividual or set of individuals have access to a resource under certainconditions and whether the first level and second level rules, policiesor policy domains associated with a resource operate as intended. In oneembodiment, an administrator accesses the Access Tester using a GUI onAccess Server 40. In one implementation, the system tests access to aresource without actually authenticating or authorizing access to theresource. Thus, the system is testing a successfully authenticateduser's access to the resource. In step 2260, the administrator enters aURL (or other identities) for a resource to be tested. In onealternative, multiple URLs can be entered so that the test is performedfor multiple resources. In another alternative, the administrator canselect to test for all possible resources so that the Access Tester willdetermine which resources are available to the users identified for thetest. In step 2262, the administrator selects the HTTP request methodsthat the administrator wants to test. If no HTTP request methods areentered, the system will test all HTTP request methods. Protocols otherthan HTTP can also be used. In accordance with the present inventionother protocols besides HTTP can be used. If the administrator wants toknow if a particular computer can access the resource, the administratorcan enter the computer's IP address in step 2264. If no IP address isentered in step 2264, then the test will not be limited to anyparticular computer.

In step 2266 of FIG. 57, the administrator can enter date and timerestrictions. In one embodiment, the administrator can indicate that anytime and day can be used so that the timing and date restrictions do notrestrict the test. Alternatively, the administrator can enter a specifictime and/or date for testing. The date and time information can identifya specific date and time or ranges of dates and times. As discussedabove, policies can be configured to allow certain access by users atcertain times on certain dates. In step 2268, the administrator selectswhich users to test access for. The administrator can request testingfor all possible users or subsets thereof. If the user desires to testfor selected users, the administrator can identify individual users.Alternatively, the administrator can use filters, rules, or roles toidentify subsets of users. Testing for all users allows an administratorto see which users have access to a particular resource. Steps 2260-2268are information gathering steps. In one embodiment, they are performedby having an administrator enter information into Access Manager 40. Inother embodiments, this information is provided to the Access Tester viaa file, a software process, information exchange protocols such as XML,etc.

Steps 2270-2282 are performed by the Access Tester in order to testaccess to the resource in question. In step 2270, the policy domain isidentified for the URL entered in step 2260 using the processesdescribed above. In step 2272, the system searches for a policyassociated with the URL in accordance with the processes describedabove. If more than one URL was entered in step 2260, than more than onepolicy or more than one policy domain may be identified. In step 2274,the Access Tester chooses one user from the set of users selected instep 2268 and the identity profile for the chosen user is accessed(optional). In step 2276, authorization is checked for that user. Step2276 is performed in a similar manner as described above with respect tostep 756 of FIG. 22, except that after it is determined whether the useris authorized, no log entry is created and the user is not actuallyauthorized. If a policy was found in step 2272, then the authorizationrules for the policy are used in step 2276. If no policy was found instep 2272, then the default authorization rules for the policy domainare used in step 2276. The information from steps 2262, 2264, and 2266,and the user's identity profile (optional) are used to determine whetherthe one or more applicable authorization rules are satisfied. If theyare satisfied, then it is determined that the particular user isauthorized to access the resource under the conditions entered in steps2260-2268. In step 2278, it is determined whether there are more usersfrom the set of users identified in step 2268. If there are more users,another user is chosen in step 2280 and the identity profile for thatuser is accessed. After step 2280, the method loops back to step 2276.If there are no more users to consider (step 2278), then the results aredisplayed in step 2282.

In one embodiment, the method of displaying and/or the contents of theresults in step 2282 are configurable. For example, the administratorcan select whether the matching policy domain, policy and/or matchingrules should be displayed. One embodiment of step 2282 includesdisplaying a table (not shown) in a GUI listing all users. For eachuser, the table displays the URL in question, the request method tested,the policy domain, the policy, the authorization rules, date and timeinformation, IP address information, and an indication of whether theuser is authorized to access the resource. In one embodiment, only aconfigurable subset of this information is displayed. It is possiblethat a user may have multiple entries in the result table, for example,when the date and timing information results in access grants at sometimes and access denials at other times. The results table allows anadministrator to determine whether the policies created for a particularresource or set of resources are appropriate. In addition, theadministrator can use the Access Tester to determine whether specificusers have appropriate access rights. The Access Tester quickly allowsan administrator to verify authorization rules created for particularpolicy domains and/or policies. In alternative embodiments of step 2282,the results are reported in a file, in XML, on a printer, using voice,etc. In one embodiment, the results reported could include an indicationthat access is granted, access is denied, there is redirection to adifferent resource or it is undetermined (e.g. a custom authorizationplug-in cannot be loaded).

Various alternatives to the above-described embodiments are also withinthe spirit of the present invention. For example, in one embodiment, thesystem of FIG. 1 can include a separate Identity Server which willperform many (or all) of the tasks associated with managing the IdentitySystem. In one embodiment, such an Identity Server would include aPublisher, a User Manager, a Group Manager and an Organization Manager.

The Publisher is an application that lets a user publish LDAP-baseddirectory information about users, reporting structures, departments,offices and other resources stored in enterprise directories. The UserManager is responsible for password management, certificate management,and delegation administration of user identity profiles. For example,the User Manager can create and delete users, roles, rights andcredentials.

The Group Manager manages groups. When a company is setting up anExtranet/Internet or ASP services, the company will need to provide onlycertain groups of people with access to the application/resources thatthey are making available. The entities in a group can be determined byspecifically adding a person or group, or by identifying a specificattribute or value in user identity profiles. Companies can use thesemethods to use roles/rights management, or to grant/deny access to theapplications that they will need. The Group Manager will manage thisgroup functionality, including supporting multiple types of groups,managing group ownership, group membership, group administration, etc.

The Organization Manager is used to manage organizations. When companiesare dealing with outside partners, suppliers, or other organizations(internal or external), the companies need a way to manage thoseorganizations including creating the entity, modifying it or deletingit. There are three fundamental data structures that are used toorganize directory data in the directory server: (1) User objects forthe actual information about the user; (2) group objects for collectionsof users; and (3) organization objects, which are containers for user,group and other organization objects. Organizations can be created andremoved from the system. Additionally, organizations can be managed by amanager, self managed, or managed in a delegated fashion.

The system can also be implemented with multiple Identity Servers. EachIdentity Server will have its own cache or set of caches. In onescenario, if one of the Identity Servers change it cache, it willcommunicate to the others to flush their cache.

Another alternative embodiment will include Public Key Infrastructure(PKI) integration. By deploying PKI, customers can issue certificates tovarious users. PKI is a key technology for enabling e-business ande-commerce by making transactions and interactions that are more securebetween companies and across the Internet.

Another embodiment includes Pre and Post Processing (PPP). PPPserver-side hooks allow customers to extend the business logic of theIdentity Systems by communicating with other systems before and after anevent happens in the Identity System (or Access System). Customers canhook shared libraries, Pearl scripts or any other applications that canbe called from specific well defined points in the processing logic ofthe application. As an example, during the user creation work flowprocess, a customer might want to call out to another system thatcreates an account for a user and provides information that should bestored in the user identity profile. As part of the call out,information can be returned to the Identity System. PPP can be used toperform data validation and password management. PPP could also be usedas a notification engine (e.g. when a given action occurs, send anemail).

In one embodiment, the system is implemented as a three-tierarchitecture. This allows the Identity System to be placed behind afirewall, while the only component exposed outside the firewall (or inthe DMZ) is a Web Server with a Web Pass plug-in. The Web Pass plug-inis a plug-in for the Web Server that communicates with the IdentityServer. The Web Pass Plug-in is analogous to the Web Gate for the accesssystem. This allows customers to run the system with enhanced securityand provides another point to do fail over, load balance and utilizeredundant servers.

In another embodiment, the system of FIG. 1 can accept input in XMLformat and provide output in XML format. Additionally, the system willmake use of XML remote procedure calls (RPC).

In an alternative implementation, the system could attempt to validatedata on input. If a user or application enters data into the system thatis outside predefined constraints, the data will be rejected.

In another embodiment, Access System authentication policies and schemescan be used by third party applications through an API. For example, theAPI allows third party developers to create clients to performauthentication while running on application servers. Authenticated usersessions can be shared among application components, allowing creationof session tokens compatible with Access System cookies and re-creationof user sessions from session tokens imported from Web Gates or othercomponents. In one embodiment, Java servlets, Enterprise Java Beans(EJB's), and standalone Java, C++, and C programs are supported.

In one variation, Access System authorization rules and actions can becreated by third party developers through an API. In one embodiment,these custom authorization rules and actions are programmed in C code.In another embodiment, custom authorization rules and actions can residein an Access System with preexisting authorization rules and actions.

In another embodiment, “affiliate” Web Gates are installed on remote WebServers to provide single sign-on authentication across multipleorganizations. The affiliate Web Gates can access Web Gates of theAccess System, but cannot directly communicate with Access Server 34.For example, a first company may maintain a web site protected by anAccess System in accordance with the present invention. If the firstcompany agrees to allow customers of a second company to access a subsetof resources on the first company's web site, an affiliate Web Gate willbe installed on the second company's web server. When a customer of thesecond company requests resources from this subset, the affiliate WebGate will request a Web Gate of the Access System to authenticate thecustomer. The Access System Web Gate will return a successful orunsuccessful authentication result to the affiliate Web Gate.

FIG. 4, above, shows a hierarchical directory structure. Other datastructures can also be used. One example of a suitable alternative is aflat data structure that does not include a hierarchy. Another suitableexample includes a fat tree, which is a hierarchy that has few levelsand each level is wide (a lot of nodes). One additional feature that canbe used with various data structures is the implementation of a variablesearch base. In some embodiments, a user can access the entirehierarchy, subject to access rules and localized access filters. Inother embodiments, users will be limited to only accessing portions ofthe hierarchy. For example, the system can be set up so that usersunderneath a particular node in the hierarchy can only access othernodes below that particular node. This restriction on access is donebefore applying any access criteria and localized access filters, andcan be thought of as restricting the search base. In effect, the toproot of the hierarchy can then vary on a per user or group basis.

Another alternative embodiment for the Identity System is allow the flowof managing user identity profiles to be configurable so that they canmatch the procedures of the company or entity.

Policy domain information and policy information can be stored with aresource, with a resource's information in the directory server or in alocation on the directory server (or elsewhere) for storing sets ofpolicy domain information and policy information. Additionally, theabove described system can work with one directory server or multipledirectory servers.

The foregoing detailed description of the invention has been presentedfor purposes of illustration and description. It is not intended to beexhaustive or to limit the invention to the precise form disclosed. Manymodifications and variations are possible in light of the aboveteaching. The described embodiments were chosen in order to best explainthe principles of the invention and its practical application to therebyenable others skilled in the art to best utilize the invention invarious embodiments and with various modifications as are suited to theparticular use contemplated. It is intended that the scope of theinvention be defined by the claims appended hereto.

1.-28. (canceled)
 29. A method for flushing cache memories in an AccessSystem, comprising the steps of: detecting a change to data residing onan LDAP directory server; assigning a first global sequence number tosaid detected change; transmitting a synchronization record to an AccessServer of said system, said synchronization record identifying saidchanged data; flushing said changed data identified by saidsynchronization record from caches of said Access Server; storing saidfirst global sequence number in said Access Server; storing saidsynchronization record in said Access Server; transmitting said firstglobal sequence number from said Access Server to a component of saidsystem, said component storing a second global sequence number;comparing said first global sequence number to said second globalsequence number; requesting all synchronization records comprisingglobal sequence numbers generated after said second global sequencenumber; requesting all synchronization records identified by a list ofsynchronization records stored by said component; transmittingsynchronization records to said component; flushing from caches of saidcomponent all data identified by said synchronization recordstransmitted to said component; and storing said first global sequencenumber in said component. 30.-39. (canceled)
 40. A method for flushingcache memories in a network-based system, the method comprising:detecting at an administration server for said system a change to dataresiding on a directory server; transmitting a synchronization record toa component of said system, said synchronization record identifying saiddata, wherein a web server comprises said component; and flushing saiddata identified in said synchronization record from caches of saidcomponent.
 41. The method of claim 40, further comprising: storing saidsynchronization record in said component.
 42. The method of claim 40,further comprising: assigning a first global sequence number to saiddetected change; and storing said first global sequence number in saidcomponent.
 43. The method of claim 42, further comprising: comparingsaid first global sequence number to a second global sequence numberstored by said component; requesting all synchronization recordscomprising global sequence numbers generated after said second globalsequence number; and flushing from said caches of said component allchanged data identified by said synchronization records transmitted tosaid component, in place of said step of flushing.
 44. The method ofclaim 43, said method further comprising the steps of: requesting allsynchronization records identified by a list of synchronization recordsstored by said component; and removing said transmitted synchronizationrecords from said list.
 45. The method of claim 42, wherein: saiddetecting and assigning are performed by an Access Manager running on anAdministration Server.
 46. The method of claim 42, wherein: saidsynchronization record comprises: said first global sequence number; anidentification of said changed data; a description of a type of saiddetected change; and a time at which said step of detecting occurred.47. The method of claim 40, wherein: said component is a Web Serverplug-in.
 48. The method of claim 47, wherein: said plug-in is an NSAPIWeb Server plug-in.
 49. The method of claim 47, wherein: said plug-in isan ISAPI Web Server plug-in.
 50. The method of claim 47, wherein: saidcaches of said plug-in comprise: a resource cache; and an authenticationscheme cache.
 51. The method of claim 40, wherein: said system is anAccess System.
 52. The method of claim 51, wherein: said data is anattribute of a user identity profile.
 53. The method of claim 51,wherein: said data is a default authentication rule specifying a defaultchallenge method for verifying user identities to authenticate users forresources mapped to a policy domain.
 54. The method of claim 51,wherein: said data is a policy authentication rule specifying achallenge method for verifying user identities to authenticate users forresources matched to a policy.
 55. The method of claim 51, wherein: saiddata is a first level authorization rule for granting user access toresources in said Access System.
 56. The method of claim 51, wherein:said data is a second level authorization rule for granting user accessto a subset of resources in said Access System.
 57. The method of claim51, wherein: said data is a first level auditing rule specifying adefault set of information logged in response to an access system eventin said Access System.
 58. The method of claim 51, wherein: said data isa second level auditing rule specifying a set of information logged inresponse to an access system event pertaining to a subset of resourcesin said Access System.
 59. The method of claim 40, wherein: said systemis an Access Management System.
 60. The method of claim 59, wherein:said data is a policy domain.
 61. The method of claim 40, wherein: saidserver is an LDAP directory server.
 62. The method of claim 40, wherein:said directory server utilizes LDAP, said system further comprising: anAdministration Server; a plurality of Access Servers utilizing LDAP; anda plurality of Web Servers running Web Server plug-ins.
 63. The methodof claim 40, wherein: said detected change is a modification to saiddata.
 64. The method of claim 40, wherein: said detected change is adeletion of said data.
 65. The method of claim 40, wherein: saiddetected change is an addition of said data.
 66. One or more processorreadable storage devices having processor readable code embodied on saidprocessor readable storage devices, said processor readable code forprogramming one or more processors, said processor readable codecomprising: code for detecting a change to data residing on a server;code for transmitting a synchronization record to a component of saidsystem, said synchronization record identifying said data, wherein a webserver comprises said component; and code for flushing said dataidentified in said synchronization record from caches of said component.67. One or more processor readable storage devices according to claim66, wherein said processor readable code further comprises: code forstoring said synchronization record in said component.
 68. One or moreprocessor readable storage devices according to claim 30, wherein saidprocessor readable code further comprises: code for assigning a firstglobal sequence number to said detected change; and code for storingsaid first global sequence number in said component.
 69. One or moreprocessor readable storage devices according to claim 68, wherein saidprocessor readable code further comprises: code for comparing said firstglobal sequence number to a second global sequence number stored by saidcomponent; code for requesting all synchronization records comprisingglobal sequence numbers generated after said second global sequencenumber; and code flushing from said caches of said component all changeddata identified by said synchronization records transmitted to saidcomponent, in place of said step of flushing.
 70. One or more processorreadable storage devices according to claim 69, wherein said processorreadable code further comprises: code for requesting all synchronizationrecords identified by a list of synchronization records stored by saidcomponent; and code for removing said transmitted synchronizationrecords from said list.
 71. An apparatus, comprising: a communicationinterface; one or more storage devices; and one or more processors incommunication with said one or more storage devices and saidcommunication interface, said one or more storage devices comprisingprocessor readable code for programming said one or more processors,said processor readable code comprising: code for detecting a change todata residing on a server, code for transmitting a synchronizationrecord to a component of said system, said synchronization recordidentifying said data, wherein a web server comprises said component;and code for flushing said data identified in said synchronizationrecord from caches of said component.
 72. An apparatus according toclaim 71, wherein said processor readable code further comprises: codefor storing said synchronization record in said component.
 73. Anapparatus according to claim 71, wherein said processor readable codefurther comprises: code for assigning a first global sequence number tosaid detected change; and code for storing said first global sequencenumber in said component.
 74. An apparatus according to claim 73,wherein said processor readable code further comprises: code forcomparing said first global sequence number to a second global sequencenumber stored by said component; code for requesting all synchronizationrecords comprising global sequence numbers generated after said secondglobal sequence number; and code for flushing from said caches of saidcomponent all changed data identified by said synchronization recordstransmitted to said component, in place of said step of flushing.
 75. Anapparatus according to claim 74, wherein said processor readable codefurther comprises: code for requesting all synchronization recordsidentified by a list of synchronization records stored by saidcomponent; and code for removing said transmitted synchronizationrecords from said list.
 76. A system, comprising: a web servercomprising a component; a directory server in communication with the webserver; and an administration server in communication with the webserver and the directory server, wherein the administration servercomprises computer readable code executable by the administrationserver, the computer readable code comprising: code for detecting achange to data residing on the directory server; and code fortransmitting a synchronization record for reception by the web server,wherein the synchronization record identifies a set of data to beflushed from a cache at the web server; wherein the web server isconfigured to flush from one or more caches of the component the set ofdata identified in the synchronization record.
 77. The system recited byclaim 76, wherein the component is a web server plug in.